aai-core/src/main/java/org/openecomp/aai/audit/ListEndpoints.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * org.openecomp.aai
   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
  21 package org.openecomp.aai.audit;
  22
  23 import java.util.ArrayList;
  24 import java.util.HashMap;
  25 import java.util.HashSet;
  26 import java.util.LinkedHashSet;
  27 import java.util.List;
  28 import java.util.Map;
  29 import java.util.Set;
  30 import java.util.regex.Matcher;
  31 import java.util.regex.Pattern;
  32
  33 import org.apache.commons.lang.StringUtils;
  34
  35 import org.openecomp.aai.db.props.AAIProperties;
  36 import org.openecomp.aai.introspection.Introspector;
  37 import org.openecomp.aai.introspection.Loader;
  38 import org.openecomp.aai.introspection.LoaderFactory;
  39 import org.openecomp.aai.introspection.ModelType;
  40 import org.openecomp.aai.introspection.Version;
  41 import org.openecomp.aai.introspection.exceptions.AAIUnknownObjectException;
  42 import com.att.eelf.configuration.EELFLogger;
  43 import com.att.eelf.configuration.EELFManager;
  44 import com.google.common.base.CaseFormat;
  45
  46 /**
  47  * The Class ListEndpoints.
  48  */
  49 public class ListEndpoints {
  50
  51         private static final EELFLogger LOGGER = EELFManager.getInstance().getLogger(ListEndpoints.class);
  52
  53         private final String start = "inventory";
  54         private final String[] blacklist = { "search", "aai-internal" };
  55
  56         private List<String> endpoints = new ArrayList<>();
  57         private Map<String, String> endpointToLogicalName = new HashMap<String, String>();
  58
  59         /**
  60          * The main method.
  61          *
  62          * @param args the arguments
  63          */
  64         public static void main(String[] args) {
  65                 ListEndpoints endPoints = new ListEndpoints(AAIProperties.LATEST);
  66
  67                 System.out.println(endPoints.toString("relationship-list"));
  68
  69         }
  70
  71         /**
  72          * Instantiates a new list endpoints.
  73          *
  74          * @param version the version
  75          */
  76         public ListEndpoints(Version version) {
  77
  78                 Loader loader = LoaderFactory.createLoaderForVersion(ModelType.MOXY, version);
  79
  80                 try {
  81                         final Introspector start = loader.introspectorFromName(this.start);
  82                         Set<String> startMap = new HashSet<>();
  83                         beginAudit(start, "/aai/" + version, startMap);
  84                 } catch (AAIUnknownObjectException e) {
  85                         throw new RuntimeException("Failed to find object " + this.start + ", cannot run ListEndpoints audit");
  86                 }
  87         }
  88
  89         /**
  90          * Begin audit.
  91          *
  92          * @param obj the obj
  93          * @param uri the uri
  94          */
  95         private void beginAudit(Introspector obj, String uri, Set<String> visited) {
  96
  97                 String currentUri = "";
  98
  99                 if (!obj.getDbName().equals("inventory")) {
 100                         currentUri = uri + obj.getGenericURI();
 101                 } else {
 102                         currentUri = uri;
 103                 }
 104                 if (obj.getName().equals("relationship-data") || obj.getName().equals("related-to-property")) {
 105                         return;
 106                 }
 107                 if (!obj.isContainer()) {
 108                         endpoints.add(currentUri);
 109                 }
 110
 111                 String dbName = obj.getDbName();
 112
 113                 populateLogicalName(obj, uri, currentUri);
 114
 115                 Set<String> properties = obj.getProperties();
 116                 Set<String> props = new LinkedHashSet<>(properties);
 117                 if (obj.isContainer()) {
 118                         for (String key : visited) {
 119                                 if (props.remove(key)) {
 120                                         try {
 121                                                 endpoints.add(currentUri + obj.getLoader().introspectorFromName(key).getGenericURI());
 122                                         } catch (AAIUnknownObjectException e) {
 123                                                 LOGGER.warn("Skipping endpoint for " + key + " (Unknown object)", e);
 124                                         }
 125                                 }
 126                         }
 127                 }
 128
 129                 outer: for (String propName : props) {
 130
 131                         for (String item : blacklist) {
 132                                 if (propName.equals(item)) {
 133                                         continue outer;
 134                                 }
 135                         }
 136                         if (obj.isListType(propName)) {
 137                                 if (obj.isComplexGenericType(propName)) {
 138                                         try {
 139                                                 final Introspector nestedObj = obj.newIntrospectorInstanceOfNestedProperty(propName);
 140                                                 Set<String> newVisited = new HashSet<>();
 141                                                 newVisited.addAll(visited);
 142                                                 newVisited.add(nestedObj.getDbName());
 143                                                 beginAudit(
 144                                                                 nestedObj,
 145                                                                 currentUri,
 146                                                                 newVisited
 147                                                                 );
 148                                         } catch (AAIUnknownObjectException e) {
 149                                                 LOGGER.warn("Skipping nested endpoint for " + propName + " (Unknown Object)", e);
 150                                         }
 151                                 }
 152                         } else if (obj.isComplexType(propName)) {
 153                                 try {
 154                                         final Introspector nestedObj = obj.newIntrospectorInstanceOfProperty(propName);
 155                                         Set<String> newVisited = new HashSet<>();
 156                                         newVisited.addAll(visited);
 157                                         newVisited.add(nestedObj.getDbName());
 158                                         beginAudit(nestedObj,
 159                                                         currentUri,
 160                                                         visited
 161                                                         );
 162                                 } catch (AAIUnknownObjectException e) {
 163                                         LOGGER.warn("Skipping nested enpoint for " + propName + " (Unknown Object)", e);
 164                                 }
 165                         }
 166                 }
 167
 168         }
 169
 170         /**
 171          * Populate logical name.
 172          *
 173          * @param obj the obj
 174          * @param uri the uri
 175          * @param currentUri the current uri
 176          */
 177         private void populateLogicalName(Introspector obj, String uri, String currentUri) {
 178
 179                 if (obj.getDbName().equals("inventory") || currentUri.split("/").length <= 4 || currentUri.endsWith("relationship-list")) {
 180                         return;
 181                 }
 182
 183                 if (uri.endsWith("/relationship-list")) {
 184                         uri = uri.substring(0, uri.lastIndexOf("/"));
 185                 }
 186
 187                 String logicalName = "";
 188                 String keys = "";
 189
 190
 191                 if (!obj.getAllKeys().isEmpty()) {
 192
 193                         Pattern p = Pattern.compile("/\\{[\\w\\d\\-]+\\}/\\{[\\w\\d\\-]+\\}+$");
 194                         Matcher m = p.matcher(currentUri);
 195
 196                         if (m.find()) {
 197                                 keys = StringUtils.join(obj.getAllKeys(), "-and-");
 198                         } else {
 199                                 keys = StringUtils.join(obj.getAllKeys(), "-or-");
 200                         }
 201                         keys = CaseFormat.LOWER_HYPHEN.to(CaseFormat.UPPER_CAMEL, keys);
 202                         if (!keys.isEmpty()) {
 203                                 keys = "With" + keys;
 204                         }
 205                 }
 206
 207                 logicalName = CaseFormat.LOWER_HYPHEN.to(CaseFormat.UPPER_CAMEL, obj.getDbName()) + keys;
 208
 209                 if (endpointToLogicalName.containsKey(uri) && uri.endsWith("}")) {
 210                         logicalName = logicalName + "From" + endpointToLogicalName.get(uri);
 211                 } else if (endpointToLogicalName.containsKey(uri.substring(0, uri.lastIndexOf("/")))) {
 212                         logicalName = logicalName + "From" + endpointToLogicalName.get(uri.substring(0, uri.lastIndexOf("/")));
 213                 }
 214
 215                 endpointToLogicalName.put(currentUri, logicalName);
 216
 217         }
 218
 219         /**
 220          * Gets the logical names.
 221          *
 222          * @return the logical names
 223          */
 224         public Map<String, String> getLogicalNames() {
 225
 226                 return endpointToLogicalName;
 227
 228         }
 229
 230         /**
 231          * Gets the endpoints.
 232          *
 233          * @return the endpoints
 234          */
 235         public List<String> getEndpoints() {
 236
 237                 return this.getEndpoints("");
 238
 239         }
 240
 241         /**
 242          * Gets the endpoints.
 243          *
 244          * @param filterOut the filter out
 245          * @return the endpoints
 246          */
 247         public List<String> getEndpoints(String filterOut) {
 248                 List<String> result = new ArrayList<>();
 249                 Pattern p = null;
 250                 Matcher m = null;
 251                 if (!filterOut.equals("")) {
 252                         p = Pattern.compile(filterOut);
 253                         m = null;
 254                 }
 255                 for (String s : endpoints) {
 256                         if (p != null) {
 257                                 m = p.matcher(s);
 258                                 if (m.find()) {
 259                                         continue;
 260                                 }
 261                         }
 262
 263                         result.add(s);
 264                 }
 265
 266                 return result;
 267
 268         }
 269
 270         /**
 271          * {@inheritDoc}
 272          */
 273         @Override
 274         public String toString() {
 275                 StringBuilder sb = new StringBuilder();
 276                 for (String s : endpoints) {
 277                         sb.append(s + "\n");
 278                 }
 279                 return sb.toString();
 280
 281         }
 282
 283         /**
 284          * To string.
 285          *
 286          * @param filterOut the filter out
 287          * @return the string
 288          */
 289         public String toString(String filterOut) {
 290                 StringBuilder sb = new StringBuilder();
 291                 Pattern p = Pattern.compile(filterOut);
 292                 Matcher m = null;
 293                 for (String s : endpoints) {
 294                         m = p.matcher(s);
 295                         if (!m.find()) {
 296                                 sb.append(s + "\n");
 297                         }
 298                 }
 299                 return sb.toString();
 300         }
 301
 302 }