Sonar cleanup and remove duplicate code
[policy/engine.git] / ONAP-XACML / src / main / java / org / onap / policy / xacml / std / pap / StdEngine.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.PDPGroup;
26 import com.att.research.xacml.api.pap.PDPPIPConfig;
27 import com.att.research.xacml.api.pap.PDPPolicy;
28 import com.att.research.xacml.api.pap.PDPStatus;
29 import com.att.research.xacml.util.XACMLProperties;
30 import com.google.common.base.Joiner;
31 import com.google.common.base.Splitter;
32 import com.google.common.collect.Sets;
33
34 import java.io.FileInputStream;
35 import java.io.IOException;
36 import java.io.InputStream;
37 import java.io.OutputStream;
38 import java.nio.file.FileVisitResult;
39 import java.nio.file.Files;
40 import java.nio.file.Path;
41 import java.nio.file.Paths;
42 import java.nio.file.SimpleFileVisitor;
43 import java.nio.file.attribute.BasicFileAttributes;
44 import java.util.ArrayList;
45 import java.util.Collections;
46 import java.util.Enumeration;
47 import java.util.HashSet;
48 import java.util.List;
49 import java.util.Properties;
50 import java.util.Set;
51 import java.util.TreeSet;
52
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.api.pap.PAPPolicyEngine;
61
62 /**
63  * This is a simple PAP engine that uses some property files and a simple directory structure in the file system to
64  * manage a policy repository and set of PDP nodes.
65  *
66  *
67  */
68 public class StdEngine extends StdPDPItemSetChangeNotifier implements PAPPolicyEngine {
69     public static final String PIP_PROPERTY_FILE = "pip.properties";
70
71     private static final String STR_ADDGROUP = "addGroup ";
72     private static final String STR_CLASS = "StdEngine";
73     private static final String STR_APPEND_NAME = ".name";
74     private static final String STR_APPEND_DESCRIPTION = ".description";
75     private static final String STR_APPEND_PDPS = ".pdps";
76
77     private static Log logger = LogFactory.getLog(StdEngine.class);
78
79     public static final String PROP_PAP_REPO = "xacml.pap.pdps";
80     public static final String PROP_PAP_GROUPS = "xacml.pap.groups";
81     public static final String PROP_PAP_GROUPS_DEFAULT = "xacml.pap.groups.default";
82     public static final String PROP_PAP_GROUPS_DEFAULT_NAME = "default";
83     // this value will be accessed from XacmlPapServlet so that we know if a default group did not exist
84     // and was just added. This way, we can add the new group to the database.
85     public boolean wasDefaultGroupJustAdded = false;
86
87     protected final Path repository;
88     protected Set<StdPDPGroup> groups;
89
90     /**
91      * StdEngine constructor.
92      *
93      * @throws PAPException PAPException
94      * @throws IOException IOException
95      */
96     public StdEngine() throws PAPException, IOException {
97         //
98         // Get the location in the file system of our repository
99         //
100         this.repository = Paths.get(XACMLProperties.getProperty(PROP_PAP_REPO));
101         //
102         // Initialize
103         //
104         this.intialize();
105     }
106
107     /**
108      * StdEngine constructor.
109      *
110      * @param properties Properties
111      * @throws PAPException PAPException
112      * @throws IOException IOException
113      */
114     public StdEngine(Properties properties) throws PAPException, IOException {
115         //
116         // Get the location in the file system of our repository
117         //
118         this.repository = Paths.get(properties.getProperty(PROP_PAP_REPO));
119         //
120         // Initialize
121         //
122         this.intialize();
123     }
124
125     /**
126      * StdEngine constructor.
127      *
128      * @param repository Path
129      * @throws PAPException PAPException
130      * @throws IOException IOException
131      */
132     public StdEngine(Path repository) throws PAPException, IOException {
133         //
134         // Save our location
135         //
136         this.repository = repository;
137         //
138         // Initialize
139         //
140         this.intialize();
141     }
142
143     private void intialize() throws PAPException, IOException {
144         //
145         // Sanity check the repository path
146         //
147         if (this.repository == null) {
148             throw new PAPException("No repository specified.");
149         }
150         if (! this.repository.toFile().exists()) {
151             Files.createDirectory(repository);
152         }
153         if (! this.repository.toFile().isDirectory()) {
154             throw new PAPException("Repository is NOT a directory: " + this.repository.toAbsolutePath());
155         }
156         if (! this.repository.toFile().canWrite()) {
157             throw new PAPException("Repository is NOT writable: " + this.repository.toAbsolutePath());
158         }
159         //
160         // Load our groups
161         //
162         this.loadGroups();
163     }
164
165     private void loadGroups() throws PAPException {
166         //
167         // Create a properties object
168         //
169         Properties properties = new Properties();
170         Path file = Paths.get(this.repository.toString(), XACMLProperties.XACML_PROPERTIES_NAME);
171         try {
172             //
173             // Load the properties
174             //
175             try (InputStream is = new FileInputStream(file.toFile())) {
176                 properties.load(is);
177             }
178
179             //
180             // Parse it
181             //
182             this.groups = this.readProperties(this.repository, properties);
183         } catch (IOException e) {
184             PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, STR_CLASS, "Failed to load properties file");
185             this.groups = new HashSet<>();
186         }
187         //
188         // Initialize the default group
189         //
190         PDPGroup defaultGroup = this.initializeDefaultGroup(file, properties);
191         logger.info("Default group is: " + defaultGroup.getId() + "=" + defaultGroup.getName());
192     }
193
194     private PDPGroup initializeDefaultGroup(Path file, Properties properties) throws PAPException {
195         wasDefaultGroupJustAdded = false;
196         //
197         // Make sure we have the default group
198         //
199         PDPGroup group = this.getDefaultGroup();
200         if (group != null) {
201             wasDefaultGroupJustAdded = true;
202             return group;
203         }
204         //
205         // We don't have the default group, create it
206         //
207         String defaultId = properties.getProperty(PROP_PAP_GROUPS_DEFAULT, PROP_PAP_GROUPS_DEFAULT_NAME);
208         if ("".equals(defaultId)) {
209             defaultId = PROP_PAP_GROUPS_DEFAULT_NAME;
210         }
211         logger.warn("Default group does NOT exist, creating " + defaultId);
212         Path defaultPath = Paths.get(this.repository.toString(), defaultId);
213         try {
214             //
215             // Does it exist?
216             //
217             if (! defaultPath.toFile().exists()) {
218                 //
219                 // Create its directory
220                 //
221                 Files.createDirectory(defaultPath);
222                 //
223                 // Create property files
224                 //
225                 {
226                     Properties props = new Properties();
227                     props.setProperty(XACMLProperties.PROP_REFERENCEDPOLICIES, "");
228                     props.setProperty(XACMLProperties.PROP_ROOTPOLICIES, "");
229                     Path policyPath = Paths.get(defaultPath.toAbsolutePath().toString(), "xacml.policy.properties");
230                     Files.createFile(policyPath);
231                     try (OutputStream os = Files.newOutputStream(policyPath)) {
232                         props.store(os, "");
233                     } catch (IOException e) {
234                         PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, STR_CLASS,
235                                 "Failed to write default policy properties");
236                     }
237                 }
238                 {
239                     Properties props = new Properties();
240                     props = setPipProperties(props);
241                     Path pipPath = Paths.get(defaultPath.toAbsolutePath().toString(), "xacml.pip.properties");
242                     Files.createFile(pipPath);
243                     try (OutputStream os = Files.newOutputStream(pipPath)) {
244                         props.store(os, "");
245                     } catch (IOException e) {
246                         PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, STR_CLASS,
247                                 "Failed to write default pip properties");
248                     }
249                 }
250             }
251             //
252             // Create the default group
253             //
254             StdPDPGroup newDefault = new StdPDPGroup(defaultId, true, PROP_PAP_GROUPS_DEFAULT_NAME,
255                     "The default group where new PDP's are put.", defaultPath);
256             //
257             // Add it to our list
258             //
259             this.groups.add(newDefault);
260             //
261             // Save our properties out since we have
262             // a new default group.
263             //
264             StdEngine.setGroupProperties(newDefault, properties);
265             //
266             // Save it to disk
267             //
268             try {
269                 try (OutputStream os = Files.newOutputStream(file)) {
270                     properties.store(os, "");
271                 }
272             } catch (IOException e) {
273                 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, STR_CLASS,
274                         "Failed to save properties with new default group information.");
275             }
276             //
277             // Return it
278             //
279             wasDefaultGroupJustAdded = true;
280             return newDefault;
281         } catch (IOException e) {
282             PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, STR_CLASS, "Failed to create default group");
283             throw new PAPException("Failed to create default group");
284         }
285     }
286
287     @Override
288     public OnapPDPGroup getDefaultGroup() throws PAPException {
289         for (OnapPDPGroup group : this.groups) {
290             if (group.isDefaultGroup()) {
291                 return group;
292             }
293         }
294         //
295         // Default group doesn't exist
296         //
297         return null;
298     }
299
300     @Override
301     public OnapPDPGroup getGroup(String id) throws PAPException {
302         for (OnapPDPGroup g : this.groups) {
303             if (g.getId().equals(id)) {
304                 return g;
305             }
306         }
307         return null;
308     }
309
310     @Override
311     public void newGroup(String name, String description) throws PAPException {
312         //
313         // Null check
314         //
315         if (name == null) {
316             throw new NullPointerException();
317         }
318         //
319         // Do we already have this group?
320         //
321         for (PDPGroup group : this.groups) {
322             if (group.getName().equals(name)) {
323                 throw new PAPException("Group with this name=" + name + " already exists.");
324             }
325         }
326
327         // create an Id that can be used as a file name and a properties file key.
328         // Ids must not contain \/:*?"<>|=,;
329         // The ID must also be unique within the current set of PDPGroups.
330         String id = createNewPdpGroupId(name);
331
332         //
333         // Construct the directory path
334         //
335         Path groupPath = Paths.get(this.repository.toString(), id);
336         //
337         // If it exists already
338         //
339         if (Files.exists(groupPath)) {
340             logger.warn(STR_ADDGROUP + id + " directory exists");
341         } else {
342             try {
343                 //
344                 // Create the directory
345                 //
346                 Files.createDirectory(groupPath);
347             } catch (IOException e) {
348                 PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, STR_CLASS, "Failed to create " + groupPath);
349                 throw new PAPException("Failed to create " + id);
350             }
351         }
352         //
353         // Create the Policies
354         //
355
356         Path policyProperties = Paths.get(groupPath.toString(), "xacml.policy.properties");
357         if (policyProperties.toFile().exists()) {
358             logger.warn(STR_ADDGROUP + id + " file exists");
359         } else {
360             Properties props = new Properties();
361             props.setProperty(XACMLProperties.PROP_REFERENCEDPOLICIES, "");
362             props.setProperty(XACMLProperties.PROP_ROOTPOLICIES, "");
363             try {
364                 Files.createFile(policyProperties);
365                 try (OutputStream os = Files.newOutputStream(policyProperties)) {
366                     props.store(os, "");
367                 }
368             } catch (IOException e) {
369                 PolicyLogger.error(MessageCodes.EXCEPTION_ERROR, e, STR_CLASS, "Failed to create policyProperties");
370                 throw new PAPException("Failed to create " + id);
371             }
372         }
373         //
374         // Create the PIP config
375         //
376         Path pipProperties = Paths.get(groupPath.toString(), "xacml.pip.properties");
377         Properties props = new Properties();
378         if (pipProperties.toFile().exists()) {
379             logger.warn(STR_ADDGROUP + id + " file exists.");
380         } else {
381             try {
382                 props = setPipProperties(props);
383                 Files.createFile(pipProperties);
384                 try (OutputStream os = Files.newOutputStream(pipProperties)) {
385                     props.store(os, "");
386                 }
387             } catch (IOException e) {
388                 PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, STR_CLASS, "Failed to create pipProperties");
389                 throw new PAPException("Failed to create " + id);
390             }
391
392         }
393         //
394         // Ok now add it
395         //
396         StdPDPGroup newGroup = new StdPDPGroup(id, name, description, groupPath);
397         // Add the default PIP configuration.
398         String list = props.getProperty(XACMLProperties.PROP_PIP_ENGINES);
399         if (list != null && list.length() > 0) {
400             Set<PDPPIPConfig> pipConfigs = new HashSet<>();
401             for (String pipID : list.split("[,]")) {
402                 StdPDPPIPConfig config = new StdPDPPIPConfig(pipID, props);
403                 if (config.isConfigured()) {
404                     pipConfigs.add(config);
405                 }
406             }
407             newGroup.setPipConfigs(pipConfigs);
408         }
409         if (this.groups.add(newGroup)) {
410             // save the new group in our properties and notify any listeners of the change
411             groupChanged(newGroup);
412         }
413
414     }
415
416     /**
417      * Helper to create a new Group ID. Use the Name field to create the Id. The Name is expected to not be null; if it
418      * is then this method throws an exception. The name is supposed to be unique within the current set of groups, so
419      * creating the ID based on the name will create a unique string.
420      *
421      * @param name String
422      * @return String
423      */
424     private String createNewPdpGroupId(String name) {
425         String id = name;
426         // replace "bad" characters with sequences that will be ok for file names and properties keys.
427         id = id.replace(" ", "_sp_");
428         id = id.replace("\t", "_tab_");
429         id = id.replace("\\", "_bksl_");
430         id = id.replace("/", "_sl_");
431         id = id.replace(":", "_col_");
432         id = id.replace("*", "_ast_");
433         id = id.replace("?", "_q_");
434         id = id.replace("\"", "_quo_");
435         id = id.replace("<", "_lt_");
436         id = id.replace(">", "_gt_");
437         id = id.replace("|", "_bar_");
438         id = id.replace("=", "_eq_");
439         id = id.replace(",", "_com_");
440         id = id.replace(";", "_scom_");
441
442         return id;
443     }
444
445     @Override
446     public OnapPDP getPDP(String pdpId) throws PAPException {
447         for (OnapPDPGroup group : this.groups) {
448             for (OnapPDP pdp : group.getOnapPdps()) {
449                 if (pdp.getId().equals(pdpId)) {
450                     return pdp;
451                 }
452             }
453         }
454         return null;
455     }
456
457     @Override
458     public void movePDP(OnapPDP pdp, OnapPDPGroup newGroup) throws PAPException {
459         if (newGroup == null) {
460             throw new NullPointerException("You must specify which group the PDP will belong to.");
461         }
462         PDPGroup currentGroup = this.getPDPGroup(pdp);
463         if (currentGroup == null) {
464             throw new PAPException("PDP must already belong to a group.");
465         }
466         if (currentGroup.equals(newGroup)) {
467             logger.warn("Already in that group.");
468             return;
469         }
470         if (currentGroup instanceof StdPDPGroup && newGroup instanceof StdPDPGroup) {
471             if (((StdPDPGroup) currentGroup).removePDP(pdp)) {
472                 boolean result = ((StdPDPGroup) newGroup).addPDP(pdp);
473                 if (result) {
474                     //
475                     // Save the configuration
476                     //
477                     this.doSave();
478                 } else {
479                     PolicyLogger.error("Failed to add to new group, putting back into original group.");
480                     if (!((StdPDPGroup) currentGroup).removePDP(pdp)) {
481                         PolicyLogger
482                                 .error(MessageCodes.ERROR_DATA_ISSUE + "Failed to put PDP back into original group.");
483                     }
484                 }
485             }
486         } else {
487             String message = "Unknown PDP group class: " + newGroup.getClass().getCanonicalName() + " and "
488                     + currentGroup.getClass().getCanonicalName();
489             logger.warn(message);
490             throw new PAPException(message);
491         }
492     }
493
494     @Override
495     public void updatePDP(OnapPDP pdp) throws PAPException {
496         PDP currentPdp = this.getPDP(pdp.getId());
497         if (currentPdp == null) {
498             String message = "Unknown PDP id '" + pdp.getId() + "'";
499             logger.warn(message);
500             throw new PAPException(message);
501         }
502
503         // the only things that the user can change are name and description
504         currentPdp.setDescription(pdp.getDescription());
505         currentPdp.setName(pdp.getName());
506         if (currentPdp instanceof OnapPDP) {
507             ((OnapPDP) currentPdp).setJmxPort(pdp.getJmxPort());
508         }
509         this.doSave();
510     }
511
512     @Override
513     public void removePDP(OnapPDP pdp) throws PAPException {
514         PDPGroup group = this.getPDPGroup(pdp);
515         if (group == null) {
516             throw new NullPointerException();
517         }
518         if (group instanceof StdPDPGroup) {
519             boolean result = ((StdPDPGroup) group).removePDP(pdp);
520             if (result) {
521                 this.doSave();
522             }
523             return;
524         }
525         String message = "Unknown PDP group class: " + group.getClass().getCanonicalName();
526         logger.warn(message);
527         throw new PAPException(message);
528     }
529
530     @Override
531     /**
532      * Should never be called - Detailed status is held on the PDP, not the PAP
533      */
534     public PDPStatus getStatus(OnapPDP pdp) throws PAPException {
535         return getPDP(pdp.getId()).getStatus();
536     }
537
538     @Override
539     public void publishPolicy(String id, String name, boolean isRoot, InputStream policy, OnapPDPGroup group)
540             throws PAPException {
541         if (group == null) {
542             throw new NullPointerException();
543         }
544         if (group instanceof StdPDPGroup && this.groups.contains(group)) {
545             ((StdPDPGroup) group).publishPolicy(id, name, isRoot, policy);
546             return;
547         }
548         logger.warn("unknown PDP Group: " + group);
549         throw new PAPException("Unknown PDP Group: " + group.getId());
550     }
551
552     @Override
553     public void copyPolicy(PDPPolicy policy, OnapPDPGroup group) throws PAPException {
554         //
555         // Currently not used on the PAP side. This is done by ((StdPDPGroup) group).copyPolicyToFile
556         //
557     }
558
559     @Override
560     public void removePolicy(PDPPolicy policy, OnapPDPGroup group) throws PAPException {
561         if (group == null) {
562             throw new NullPointerException();
563         }
564         if (group instanceof StdPDPGroup && this.groups.contains(group)) {
565             ((StdPDPGroup) group).removePolicy(policy);
566             return;
567         }
568         logger.warn("unknown PDP Group: " + group);
569         throw new PAPException("Unknown PDP Group: " + group.getId());
570     }
571
572     //
573     // HELPER methods
574     //
575
576     private Set<StdPDPGroup> readProperties(Path repository, Properties properties) throws PAPException {
577         Set<StdPDPGroup> pdpGroups = new HashSet<>();
578         //
579         // See if there is a groups property
580         //
581         String groupList = properties.getProperty(PROP_PAP_GROUPS, "");
582         if (groupList == null) {
583             logger.warn("null group list " + PROP_PAP_GROUPS);
584             groupList = "";
585         }
586         if (logger.isDebugEnabled()) {
587             logger.debug("group list: " + groupList);
588         }
589         //
590         // Iterate the groups, converting to a set ensures we have unique groups.
591         //
592         for (String id : Splitter.on(',').trimResults().omitEmptyStrings().split(groupList)) {
593             //
594             // Add our Group Object
595             //
596             StdPDPGroup newGroup = new StdPDPGroup(id.trim(),
597                     id.equals(properties.getProperty(PROP_PAP_GROUPS_DEFAULT, PROP_PAP_GROUPS_DEFAULT_NAME)),
598                     properties, Paths.get(repository.toString(), id));
599
600             //
601             // Add it in
602             //
603             pdpGroups.add(newGroup);
604         }
605         //
606         // Dump what we got
607         //
608         if (logger.isDebugEnabled()) {
609             logger.debug("PDP Group List: " + pdpGroups.toString());
610         }
611         return pdpGroups;
612     }
613
614     private void saveConfiguration() throws PAPException, IOException {
615         //
616         // Create our properties object
617         //
618         Properties properties = new Properties() {
619             private static final long serialVersionUID = 1L;
620
621             // For Debugging it is helpful for the file to be in a sorted order,
622             // any by returning the keys in the natural Alpha order for strings we get close enough.
623             // TreeSet is sorted, and this just overrides the normal Properties method to get the keys.
624             @Override
625             public synchronized Enumeration<Object> keys() {
626                 return Collections.enumeration(new TreeSet<Object>(super.keySet()));
627             }
628         };
629         //
630         // Iterate our groups
631         //
632         List<String> ids = new ArrayList<>();
633         for (PDPGroup group : this.groups) {
634             ids.add(group.getId());
635             properties.setProperty(group.getId() + STR_APPEND_NAME, group.getName() == null ? "" : group.getName());
636             properties.setProperty(group.getId() + STR_APPEND_DESCRIPTION,
637                     group.getDescription() == null ? "" : group.getDescription());
638             //
639             // Iterate its PDPs
640             //
641             List<String> pdps = new ArrayList<>();
642             for (PDP pdp : group.getPdps()) {
643                 pdps.add(pdp.getId());
644                 properties.setProperty(pdp.getId() + STR_APPEND_NAME, pdp.getName() == null ? "" : pdp.getName());
645                 properties.setProperty(pdp.getId() + STR_APPEND_DESCRIPTION,
646                         pdp.getDescription() == null ? "" : pdp.getDescription());
647                 if (pdp instanceof OnapPDP) {
648                     properties.setProperty(pdp.getId() + ".jmxport",
649                             (((OnapPDP) pdp).getJmxPort() == 0 ? "" : ((OnapPDP) pdp).getJmxPort()).toString());
650                 }
651             }
652             String pdpList = "";
653             if (pdps.size() == 1) {
654                 pdpList = pdps.get(0);
655             } else if (pdps.size() > 1) {
656                 pdpList = Joiner.on(',').skipNulls().join(pdps);
657             }
658             if (logger.isDebugEnabled()) {
659                 logger.debug("Group " + group.getId() + " PDPS: " + pdpList);
660             }
661             properties.setProperty(group.getId() + STR_APPEND_PDPS, pdpList);
662         }
663         if (ids.isEmpty()) {
664             throw new PAPException("Inconsistency - we have NO groups. We should have at least one.");
665         }
666         String groupList = "";
667         if (ids.size() == 1) {
668             groupList = ids.get(0);
669         } else if (ids.size() > 1) {
670             groupList = Joiner.on(',').skipNulls().join(ids);
671         }
672         logger.info("New Group List: " + groupList);
673
674         properties.setProperty(PROP_PAP_GROUPS, groupList);
675         //
676         // Get the default group
677         //
678         PDPGroup defaultGroup = this.getDefaultGroup();
679         if (defaultGroup == null) {
680             throw new PAPException("Invalid state - no default group.");
681         }
682         properties.setProperty(PROP_PAP_GROUPS_DEFAULT, defaultGroup.getId());
683         //
684         // Now we can save the file
685         //
686         Path file = Paths.get(this.repository.toString(), "xacml.properties");
687         try (OutputStream os = Files.newOutputStream(file)) {
688             properties.store(os, "");
689         }
690     }
691
692     /**
693      * setGroupProperties.
694      *
695      * @param group PDPGroup
696      * @param properties Properties
697      */
698     public static void setGroupProperties(PDPGroup group, Properties properties) {
699         //
700         // make sure its in the list of groups
701         //
702         Iterable<String> groups =
703                 Splitter.on(',').trimResults().omitEmptyStrings().split(properties.getProperty(PROP_PAP_GROUPS, ""));
704         boolean inList = false;
705         for (String g : groups) {
706             if (g.equals(group.getId())) {
707                 inList = true;
708             }
709         }
710         if (!inList) {
711             Set<String> grps = Sets.newHashSet(groups);
712             grps.add(group.getId());
713             String newGroupList;
714             if (grps.size() == 1) {
715                 newGroupList = grps.iterator().next();
716             } else if (grps.size() > 1) {
717                 newGroupList = Joiner.on(',').skipNulls().join(grps);
718             } else {
719                 newGroupList = "";
720             }
721             logger.info("New Group List: " + newGroupList);
722             properties.setProperty(PROP_PAP_GROUPS, newGroupList);
723         }
724         //
725         // Set its properties
726         //
727         properties.setProperty(group.getId() + STR_APPEND_NAME, group.getName());
728         properties.setProperty(group.getId() + STR_APPEND_DESCRIPTION, group.getDescription());
729         //
730         // Set its PDP list
731         //
732         if (!group.getPdps().isEmpty()) {
733             String pdpList = "";
734             if (group.getPdps().size() == 1) {
735                 pdpList = group.getPdps().iterator().next().getId();
736             } else if (group.getPdps().size() > 1) {
737                 Set<String> ids = new HashSet<>();
738                 for (PDP pdp : group.getPdps()) {
739                     ids.add(pdp.getId());
740                 }
741                 pdpList = Joiner.on(',').skipNulls().join(ids);
742             }
743             properties.setProperty(group.getId() + STR_APPEND_PDPS, pdpList);
744         } else {
745             properties.setProperty(group.getId() + STR_APPEND_PDPS, "");
746         }
747     }
748
749     /**
750      * changed.
751      */
752     public void changed() {
753         if (logger.isDebugEnabled()) {
754             logger.debug("changed");
755         }
756         this.doSave();
757         this.fireChanged();
758     }
759
760     /**
761      * groupChanged.
762      *
763      * @param group OnapPDPGroup
764      */
765     public void groupChanged(OnapPDPGroup group) {
766         if (logger.isDebugEnabled()) {
767             logger.debug("groupChanged: " + group);
768         }
769         this.doSave();
770         this.firePDPGroupChanged(group);
771     }
772
773     /**
774      * pdpChanged.
775      *
776      * @param pdp OnapPDP
777      */
778     public void pdpChanged(OnapPDP pdp) {
779         if (logger.isDebugEnabled()) {
780             logger.debug("pdpChanged: " + pdp);
781         }
782         this.doSave();
783         this.firePDPChanged(pdp);
784     }
785
786     private void doSave() {
787         try {
788             //
789             // Save the configuration
790             //
791             this.saveConfiguration();
792         } catch (IOException | PAPException e) {
793             PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, STR_CLASS, "Failed to save configuration");
794         }
795     }
796
797     private Properties setPipProperties(Properties props) {
798         props.setProperty(XACMLProperties.PROP_PIP_ENGINES, "AAF");
799         props.setProperty("AAF.name", "AAFEngine");
800         props.setProperty("AAF.description", "AAFEngine to communicate with AAF to take decisions");
801         props.setProperty("AAF.classname", "org.onap.policy.xacml.std.pip.engines.aaf.AAFEngine");
802         // read from PIP properties file.
803         Path file = Paths.get(PIP_PROPERTY_FILE);
804         if (file.toFile().exists()) {
805             InputStream in;
806             Properties prop = new Properties();
807             try {
808                 in = new FileInputStream(file.toFile());
809                 prop.load(in);
810             } catch (IOException e) {
811                 PolicyLogger.error(
812                         XACMLErrorConstants.ERROR_SYSTEM_ERROR + "can not load the pip properties from file" + e);
813             }
814             props = prop;
815         }
816         return props;
817     }
818
819     @Override
820     public Set<OnapPDPGroup> getOnapPDPGroups() throws PAPException {
821         final Set<OnapPDPGroup> grps = new HashSet<>();
822         for (OnapPDPGroup g : this.groups) {
823             grps.add(g);
824         }
825         return Collections.unmodifiableSet(grps);
826     }
827
828     @Override
829     public OnapPDPGroup getPDPGroup(OnapPDP pdp) throws PAPException {
830         for (OnapPDPGroup group : this.groups) {
831             if (group.getPdps().contains(pdp)) {
832                 return group;
833             }
834         }
835         return null;
836     }
837
838     @Override
839     public void setDefaultGroup(OnapPDPGroup group) throws PAPException {
840         boolean changesMade = false;
841         for (OnapPDPGroup theGroup : groups) {
842             if (theGroup.getId().equals(group.getId())) {
843                 if (!theGroup.isDefaultGroup()) {
844                     if (theGroup instanceof StdPDPGroup) {
845                         ((StdPDPGroup) theGroup).setDefault(true);
846                         changesMade = true;
847                     } else {
848                         throw new IllegalArgumentException(
849                                 "Group in groups of unknown type '" + theGroup.getClass().getName() + "'");
850                     }
851                 }
852             } else {
853                 // not the new default group
854                 if (theGroup.isDefaultGroup()) {
855                     if (theGroup instanceof StdPDPGroup) {
856                         ((StdPDPGroup) theGroup).setDefault(false);
857                         changesMade = true;
858                     } else {
859                         throw new IllegalArgumentException(
860                                 "Group in groups of unknown type '" + theGroup.getClass().getName() + "'");
861                     }
862                 }
863             }
864         }
865         if (changesMade) {
866             this.doSave();
867         }
868     }
869
870     @Override
871     public void newPDP(String id, OnapPDPGroup group, String name, String description, int jmxport)
872             throws PAPException {
873         if (group == null) {
874             throw new PAPException("You must specify which group the PDP will belong to.");
875         }
876         if (!this.groups.contains(group)) {
877             throw new PAPException("Unknown group, not in our list.");
878         }
879         for (OnapPDP p : group.getOnapPdps()) {
880             if (p.getId().equals(id)) {
881                 throw new PAPException("A PDP with this ID exists.");
882             }
883         }
884         if (group instanceof StdPDPGroup) {
885             StdPDP pdp = new StdPDP(id, name, description, jmxport);
886             if (((StdPDPGroup) group).addPDP(pdp)) {
887                 //
888                 // Save the properties and notify any listeners
889                 //
890                 pdpChanged(pdp);
891             }
892         }
893     }
894
895     @Override
896     public void updateGroup(OnapPDPGroup group, String userName) throws PAPException {
897         // To pass the userId for PDP Audit log maintenance.
898
899     }
900
901     @Override
902     public void updateGroup(OnapPDPGroup group) throws PAPException {
903         if (group == null || group.getId() == null) {
904             throw new PAPException("Group or id is null");
905         }
906         if (group.getName() == null || group.getName().trim().length() == 0) {
907             throw new PAPException("New name for group cannot be null or blank");
908         }
909         StdPDPGroup existingGroup = (StdPDPGroup) getGroup(group.getId());
910         if (existingGroup == null) {
911             throw new PAPException("Update found no existing group with id '" + group.getId() + "'");
912         }
913
914         // We do dramatically different things when the Name changes
915         // because the Name is essentially the identity of the group (as the User knows it) so when the Identity changes
916         // we have to change the group ID.
917         if (group.getName().equals(existingGroup.getName())) {
918
919             // update the disk
920             try {
921                 ((StdPDPGroup) group).saveGroupConfiguration();
922             } catch (IOException e) {
923                 throw new PAPException(
924                         "Unable to save new configuration for '" + group.getName() + "': " + e.getMessage(), e);
925             }
926             // update the group in the set by simply replacing the old instance with the new one
927             this.groups.remove(existingGroup);
928             this.groups.add((StdPDPGroup) group);
929
930         } else {
931             // the name/identity of the group has changed
932             // generate the new id
933             String newId = createNewPdpGroupId(group.getName());
934
935             // make sure no other group uses the new id
936             for (OnapPDPGroup g : groups) {
937                 if (g.getId().equals(newId)) {
938                     throw new PAPException("Replacement name maps to ID '" + newId + "' which is already in use");
939                 }
940             }
941             ((StdPDPGroup) group).setId(newId);
942
943             // rename the existing directory to the new id
944             Path oldPath = existingGroup.getDirectory();
945             Path newPath = Paths.get(oldPath.getParent().toString(), newId);
946             ((StdPDPGroup) group).setDirectory(newPath);
947
948             try {
949                 boolean success = oldPath.toFile().renameTo(newPath.toFile());
950                 if (!success) {
951                     throw new PAPException("Unable to rename directory; reason unknown");
952                 }
953             } catch (Exception e) {
954                 PolicyLogger.error(MessageCodes.ERROR_PROCESS_FLOW, e, STR_CLASS, "Unable to rename directory");
955                 throw new PAPException(
956                         "Unable to move directory from '" + oldPath + "' to '" + newPath + "': " + e.getMessage(), e);
957             }
958             // update the disk
959             try {
960                 ((StdPDPGroup) group).saveGroupConfiguration();
961             } catch (IOException e) {
962                 throw new PAPException(
963                         "Unable to save new configuration for '" + group.getName() + "': " + e.getMessage(), e);
964             }
965
966             // save the new group into the Set
967             groups.remove(existingGroup);
968             groups.add((StdPDPGroup) group);
969
970         }
971
972         // perhaps only the group changed, but if the name/id changed it may look to a listener like more than one group
973         changed();
974
975     }
976
977     @Override
978     public void removeGroup(OnapPDPGroup group, OnapPDPGroup newGroup) throws PAPException {
979         if (group == null) {
980             throw new NullPointerException();
981         }
982         //
983         // Does this group exist?
984         //
985         if (!this.groups.contains(group)) {
986             PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE + "This group doesn't exist.");
987             throw new PAPException("The group '" + group.getId() + "' does not exist");
988         }
989         //
990         // Is it the default group?
991         //
992         if (group.isDefaultGroup()) {
993             throw new PAPException("You cannot delete the default group.");
994         }
995         Set<OnapPDP> pdps = group.getOnapPdps();
996         //
997         // Are there PDPs? If so, then we need a target group
998         //
999         if (!pdps.isEmpty() && newGroup == null) {
1000             throw new NullPointerException(
1001                     "Group targeted for deletion has PDPs, you must provide a new group for them.");
1002         }
1003         //
1004         // Move the PDPs
1005         //
1006         if (!pdps.isEmpty()) {
1007             if (!(newGroup instanceof StdPDPGroup)) {
1008                 throw new PAPException("Unexpected class for newGroup: " + newGroup.getClass().getCanonicalName());
1009             }
1010             // The movePDP function will modify the set of PDPs in the group.
1011             // To avoid concurrent modification exceptions we need to duplicate the list before calling that function.
1012             List<OnapPDP> pdpList = new ArrayList<>();
1013             for (OnapPDP pdp : pdps) {
1014                 pdpList.add(pdp);
1015             }
1016             // now we can use the PDPs from the list without having ConcurrentAccessExceptions
1017             for (OnapPDP pdp : pdpList) {
1018                 this.movePDP(pdp, newGroup);
1019             }
1020         }
1021         //
1022         // remove the directory for the group
1023         //
1024         String id = group.getId();
1025         Path groupPath = Paths.get(this.repository.toString(), id);
1026         //
1027         // If it exists already
1028         //
1029         if (! groupPath.toFile().exists()) {
1030             logger.warn("removeGroup " + id + " directory does not exist" + groupPath.toString());
1031         } else {
1032             try {
1033                 Files.walkFileTree(groupPath, new SimpleFileVisitor<Path>() {
1034
1035                     @Override
1036                     public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
1037                         Files.delete(file);
1038                         return super.visitFile(file, attrs);
1039                     }
1040
1041                 });
1042                 //
1043                 // delete the directory
1044                 //
1045                 Files.delete(groupPath);
1046             } catch (IOException e) {
1047                 PolicyLogger.error(MessageCodes.ERROR_DATA_ISSUE, e, STR_CLASS, "Failed to delete " + groupPath);
1048                 throw new PAPException("Failed to delete " + id);
1049             }
1050         }
1051
1052         // remove the group from the set of all groups
1053         groups.remove(group);
1054
1055         //
1056         // Save changes
1057         //
1058         changed();
1059         this.doSave();
1060     }
1061
1062 }

© 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