src/main/java/org/onap/aai/datarouter/policy/EntityEventPolicy.java

   1 /**
   2  * ============LICENSE_START=======================================================
   3  * org.onap.aai
   4  * ================================================================================
   5  * Copyright © 2017-2018 AT&T Intellectual Property. All rights reserved.
   6  * Copyright © 2017-2018 Amdocs
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *       http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END=========================================================
  20  */
  21 package org.onap.aai.datarouter.policy;
  22
  23 import java.io.FileNotFoundException;
  24 import java.io.IOException;
  25 import java.security.NoSuchAlgorithmException;
  26 import java.util.ArrayList;
  27 import java.util.Arrays;
  28 import java.util.Collection;
  29 import java.util.Collections;
  30 import java.util.HashMap;
  31 import java.util.Iterator;
  32 import java.util.List;
  33 import java.util.Map;
  34
  35 import org.apache.camel.Exchange;
  36 import org.apache.camel.Processor;
  37 import org.eclipse.persistence.dynamic.DynamicType;
  38 import org.eclipse.persistence.internal.helper.DatabaseField;
  39 import org.eclipse.persistence.jaxb.dynamic.DynamicJAXBContext;
  40 import org.eclipse.persistence.oxm.MediaType;
  41 import org.json.JSONException;
  42 import org.json.JSONObject;
  43 import org.onap.aai.datarouter.entity.AaiEventEntity;
  44 import org.onap.aai.datarouter.entity.AggregationEntity;
  45 import org.onap.aai.datarouter.entity.DocumentStoreDataEntity;
  46 import org.onap.aai.datarouter.entity.OxmEntityDescriptor;
  47 import org.onap.aai.datarouter.entity.SuggestionSearchEntity;
  48 import org.onap.aai.datarouter.entity.TopographicalEntity;
  49 import org.onap.aai.datarouter.entity.UebEventHeader;
  50 import org.onap.aai.datarouter.logging.EntityEventPolicyMsgs;
  51 import org.onap.aai.datarouter.util.CrossEntityReference;
  52 import org.onap.aai.datarouter.util.EntityOxmReferenceHelper;
  53 import org.onap.aai.datarouter.util.ExternalOxmModelProcessor;
  54 import org.onap.aai.datarouter.util.NodeUtils;
  55 import org.onap.aai.datarouter.schema.OxmModelLoader;
  56 import org.onap.aai.datarouter.util.RouterServiceUtil;
  57 import org.onap.aai.datarouter.util.SearchServiceAgent;
  58 import org.onap.aai.datarouter.util.SearchSuggestionPermutation;
  59 import org.onap.aai.datarouter.util.Version;
  60 import org.onap.aai.datarouter.util.VersionedOxmEntities;
  61 import org.onap.aai.cl.api.Logger;
  62 import org.onap.aai.cl.eelf.LoggerFactory;
  63 import org.onap.aai.cl.mdc.MdcContext;
  64 import org.onap.aai.restclient.client.Headers;
  65 import org.onap.aai.restclient.client.OperationResult;
  66 import org.onap.aai.restclient.rest.HttpUtil;
  67 import org.slf4j.MDC;
  68
  69 import com.fasterxml.jackson.core.JsonProcessingException;
  70 import com.fasterxml.jackson.databind.JsonNode;
  71 import com.fasterxml.jackson.databind.ObjectMapper;
  72 import com.fasterxml.jackson.databind.ObjectWriter;
  73 import com.fasterxml.jackson.databind.node.ObjectNode;
  74
  75 public class EntityEventPolicy implements Processor {
  76
  77   public static final String additionalInfo = "Response of AAIEntityEventPolicy";
  78   private static final String ENTITY_SEARCH_SCHEMA = "entitysearch_schema.json";
  79   private static final String TOPOGRAPHICAL_SEARCH_SCHEMA = "topographysearch_schema.json";
  80   private Collection<ExternalOxmModelProcessor> externalOxmModelProcessors;
  81
  82   private static final String EVENT_HEADER = "event-header";
  83   private static final String ENTITY_HEADER = "entity";
  84   private static final String ACTION_CREATE = "create";
  85   private static final String ACTION_DELETE = "delete";
  86   private static final String ACTION_UPDATE = "update";
  87   private static final String PROCESS_AAI_EVENT = "Process AAI Event";
  88   private static final String TOPO_LAT = "latitude";
  89   private static final String TOPO_LONG = "longitude";
  90
  91   private static final List<String> SUPPORTED_ACTIONS =
  92       Arrays.asList(ACTION_CREATE, ACTION_UPDATE, ACTION_DELETE);
  93
  94   Map<String, DynamicJAXBContext> oxmVersionContextMap = new HashMap<>();
  95   private String oxmVersion = null;
  96
  97   /** Agent for communicating with the Search Service. */
  98   private SearchServiceAgent searchAgent = null;
  99
 100   /** Search index name for storing AAI event entities. */
 101   private String entitySearchIndex;
 102
 103   /** Search index name for storing topographical search data. */
 104   private String topographicalSearchIndex;
 105
 106   /** Search index name for suggestive search data. */
 107   private String aggregateGenericVnfIndex;
 108
 109   private String autosuggestIndex;
 110
 111   private String srcDomain;
 112
 113   private Logger logger;
 114   private Logger metricsLogger;
 115
 116   public enum ResponseType {
 117     SUCCESS, PARTIAL_SUCCESS, FAILURE;
 118   };
 119
 120   public EntityEventPolicy(EntityEventPolicyConfig config) throws FileNotFoundException {
 121     LoggerFactory loggerFactoryInstance = LoggerFactory.getInstance();
 122     logger = loggerFactoryInstance.getLogger(EntityEventPolicy.class.getName());
 123     metricsLogger = loggerFactoryInstance.getMetricsLogger(EntityEventPolicy.class.getName());
 124
 125
 126     srcDomain = config.getSourceDomain();
 127
 128     // Populate the index names.
 129     entitySearchIndex        = config.getSearchEntitySearchIndex();
 130     topographicalSearchIndex = config.getSearchTopographySearchIndex();
 131     aggregateGenericVnfIndex = config.getSearchAggregationVnfIndex();
 132     autosuggestIndex             = config.getSearchEntityAutoSuggestIndex();
 133
 134     // Instantiate the agent that we will use for interacting with the Search Service.
 135     searchAgent = new SearchServiceAgent(config.getSearchCertName(),
 136                                          config.getSearchKeystore(),
 137                                          config.getSearchKeystorePwd(),
 138                                          EntityEventPolicy.concatSubUri(config.getSearchBaseUrl(),
 139                                                                         config.getSearchEndpoint()),
 140                                          config.getSearchEndpointDocuments(),
 141                                          logger);
 142
 143     this.externalOxmModelProcessors = new ArrayList<>();
 144     this.externalOxmModelProcessors.add(EntityOxmReferenceHelper.getInstance());
 145     OxmModelLoader.registerExternalOxmModelProcessors(externalOxmModelProcessors);
 146     OxmModelLoader.loadModels();
 147     oxmVersionContextMap = OxmModelLoader.getVersionContextMap();
 148     parseLatestOxmVersion();
 149   }
 150
 151   private void parseLatestOxmVersion() {
 152     int latestVersion = -1;
 153     if (oxmVersionContextMap != null) {
 154       Iterator it = oxmVersionContextMap.entrySet().iterator();
 155       while (it.hasNext()) {
 156         Map.Entry pair = (Map.Entry) it.next();
 157
 158         String version = pair.getKey().toString();
 159         int versionNum = Integer.parseInt(version.substring(1, version.length()));
 160
 161         if (versionNum > latestVersion) {
 162           latestVersion = versionNum;
 163           oxmVersion = pair.getKey().toString();
 164         }
 165
 166         logger.info(EntityEventPolicyMsgs.PROCESS_OXM_MODEL_FOUND, pair.getKey().toString());
 167       }
 168     } else {
 169       logger.error(EntityEventPolicyMsgs.PROCESS_OXM_MODEL_MISSING, "");
 170     }
 171   }
 172
 173   public void startup() {
 174
 175     // Create the indexes in the search service if they do not already exist.
 176     searchAgent.createSearchIndex(entitySearchIndex, ENTITY_SEARCH_SCHEMA);
 177     searchAgent.createSearchIndex(topographicalSearchIndex, TOPOGRAPHICAL_SEARCH_SCHEMA);
 178
 179     logger.info(EntityEventPolicyMsgs.ENTITY_EVENT_POLICY_REGISTERED);
 180   }
 181
 182
 183   /**
 184    * Convert object to json.
 185    *
 186    * @param object the object
 187    * @param pretty the pretty
 188    * @return the string
 189    * @throws JsonProcessingException the json processing exception
 190    */
 191   public static String convertObjectToJson(Object object, boolean pretty)
 192       throws JsonProcessingException {
 193     ObjectWriter ow;
 194
 195     if (pretty) {
 196       ow = new ObjectMapper().writer().withDefaultPrettyPrinter();
 197
 198     } else {
 199       ow = new ObjectMapper().writer();
 200     }
 201
 202     return ow.writeValueAsString(object);
 203   }
 204
 205   public void returnWithError(Exchange exchange, String payload, String errorMsg){
 206     logger.error(EntityEventPolicyMsgs.DISCARD_EVENT_NONVERBOSE, errorMsg);
 207     logger.debug(EntityEventPolicyMsgs.DISCARD_EVENT_VERBOSE, errorMsg, payload);
 208     setResponse(exchange, ResponseType.FAILURE, additionalInfo);
 209   }
 210
 211   @Override
 212   public void process(Exchange exchange) throws Exception {
 213
 214     long startTime = System.currentTimeMillis();
 215
 216     String uebPayload = exchange.getIn().getBody().toString();
 217
 218     JsonNode uebAsJson =null;
 219     ObjectMapper mapper = new ObjectMapper();
 220     try{
 221       uebAsJson = mapper.readTree(uebPayload);
 222     } catch (IOException e){
 223       returnWithError(exchange, uebPayload, "Invalid Payload");
 224       return;
 225     }
 226
 227     // Load the UEB payload data, any errors will result in a failure and discard
 228     JSONObject uebObjHeader = getUebContentAsJson(uebPayload, EVENT_HEADER);
 229     if (uebObjHeader == null) {
 230       returnWithError(exchange, uebPayload, "Payload is missing " + EVENT_HEADER);
 231       return;
 232     }
 233
 234     JSONObject uebObjEntity = getUebContentAsJson(uebPayload, ENTITY_HEADER);
 235     if (uebObjEntity == null) {
 236       returnWithError(exchange, uebPayload, "Payload is missing " + ENTITY_HEADER);
 237       return;
 238     }
 239
 240     UebEventHeader eventHeader;
 241     eventHeader = initializeUebEventHeader(uebObjHeader.toString());
 242
 243     // Get src domain from header; discard event if not originated from same domain
 244     String payloadSrcDomain = eventHeader.getDomain();
 245     if (payloadSrcDomain == null || !payloadSrcDomain.equalsIgnoreCase(this.srcDomain)) {
 246       logger.debug(EntityEventPolicyMsgs.DISCARD_EVENT_VERBOSE,
 247           "Unrecognized source domain '" + payloadSrcDomain + "'", uebPayload);
 248       logger.error(EntityEventPolicyMsgs.DISCARD_EVENT_NONVERBOSE,
 249           "Unrecognized source domain '" + payloadSrcDomain + "'");
 250
 251       setResponse(exchange, ResponseType.SUCCESS, additionalInfo);
 252       return;
 253     }
 254
 255     DynamicJAXBContext oxmJaxbContext = loadOxmContext(oxmVersion);
 256     if (oxmJaxbContext == null) {
 257       logger.error(EntityEventPolicyMsgs.OXM_VERSION_NOT_SUPPORTED, oxmVersion);
 258       logger.debug(EntityEventPolicyMsgs.DISCARD_EVENT_VERBOSE, "OXM version mismatch",
 259           uebPayload);
 260
 261       setResponse(exchange, ResponseType.FAILURE, additionalInfo);
 262       return;
 263     }
 264
 265     String action = eventHeader.getAction();
 266     if (action == null || !SUPPORTED_ACTIONS.contains(action.toLowerCase())) {
 267       logger.debug(EntityEventPolicyMsgs.DISCARD_EVENT_VERBOSE,
 268           "Unrecognized action '" + action + "'", uebPayload);
 269       logger.error(EntityEventPolicyMsgs.DISCARD_EVENT_NONVERBOSE,
 270           "Unrecognized action '" + action + "'");
 271
 272       setResponse(exchange, ResponseType.FAILURE, additionalInfo);
 273       return;
 274     }
 275
 276     String entityType = eventHeader.getEntityType();
 277     if (entityType == null) {
 278       logger.debug(EntityEventPolicyMsgs.DISCARD_EVENT_VERBOSE,
 279           "Payload header missing entity type", uebPayload);
 280       logger.error(EntityEventPolicyMsgs.DISCARD_EVENT_NONVERBOSE,
 281           "Payload header missing entity type");
 282
 283       setResponse(exchange, ResponseType.FAILURE, additionalInfo);
 284       return;
 285     }
 286
 287     String topEntityType = eventHeader.getTopEntityType();
 288     if (topEntityType == null) {
 289       logger.debug(EntityEventPolicyMsgs.DISCARD_EVENT_VERBOSE,
 290           "Payload header missing top entity type", uebPayload);
 291       logger.error(EntityEventPolicyMsgs.DISCARD_EVENT_NONVERBOSE,
 292           "Payload header top missing entity type");
 293
 294       setResponse(exchange, ResponseType.FAILURE, additionalInfo);
 295       return;
 296     }
 297
 298     String entityLink = eventHeader.getEntityLink();
 299     if (entityLink == null) {
 300       logger.debug(EntityEventPolicyMsgs.DISCARD_EVENT_VERBOSE,
 301           "Payload header missing entity link", uebPayload);
 302       logger.error(EntityEventPolicyMsgs.DISCARD_EVENT_NONVERBOSE,
 303           "Payload header missing entity link");
 304
 305       setResponse(exchange, ResponseType.FAILURE, additionalInfo);
 306       return;
 307     }
 308
 309     // log the fact that all data are in good shape
 310     logger.info(EntityEventPolicyMsgs.PROCESS_ENTITY_EVENT_POLICY_NONVERBOSE, action,
 311         entityType);
 312     logger.debug(EntityEventPolicyMsgs.PROCESS_ENTITY_EVENT_POLICY_VERBOSE, action, entityType,
 313         uebPayload);
 314
 315
 316     // Process for building AaiEventEntity object
 317     String[] entityTypeArr = entityType.split("-");
 318     String oxmEntityType = "";
 319     for (String entityWord : entityTypeArr) {
 320       oxmEntityType += entityWord.substring(0, 1).toUpperCase() + entityWord.substring(1);
 321     }
 322
 323     List<String> searchableAttr =
 324         getOxmAttributes(uebPayload, oxmJaxbContext, oxmEntityType, entityType, "searchable");
 325     if (searchableAttr == null) {
 326       logger.error(EntityEventPolicyMsgs.DISCARD_EVENT_NONVERBOSE,
 327           "Searchable attribute not found for payload entity type '" + entityType + "'");
 328       logger.debug(EntityEventPolicyMsgs.DISCARD_EVENT_VERBOSE,
 329           "Searchable attribute not found for payload entity type '" + entityType + "'",
 330           uebPayload);
 331
 332       setResponse(exchange, ResponseType.FAILURE, additionalInfo);
 333       return;
 334     }
 335
 336     String entityPrimaryKeyFieldName =
 337         getEntityPrimaryKeyFieldName(oxmJaxbContext, uebPayload, oxmEntityType, entityType);
 338     String entityPrimaryKeyFieldValue = lookupValueUsingKey(uebPayload, entityPrimaryKeyFieldName);
 339     if (entityPrimaryKeyFieldValue == null || entityPrimaryKeyFieldValue.isEmpty()) {
 340       logger.error(EntityEventPolicyMsgs.DISCARD_EVENT_NONVERBOSE,
 341           "Payload missing primary key attribute");
 342       logger.debug(EntityEventPolicyMsgs.DISCARD_EVENT_VERBOSE,
 343           "Payload missing primary key attribute", uebPayload);
 344
 345       setResponse(exchange, ResponseType.FAILURE, additionalInfo);
 346       return;
 347     }
 348
 349     AaiEventEntity aaiEventEntity = new AaiEventEntity();
 350
 351     /*
 352      * Use the OXM Model to determine the primary key field name based on the entity-type
 353      */
 354
 355     aaiEventEntity.setEntityPrimaryKeyName(entityPrimaryKeyFieldName);
 356     aaiEventEntity.setEntityPrimaryKeyValue(entityPrimaryKeyFieldValue);
 357     aaiEventEntity.setEntityType(entityType);
 358     aaiEventEntity.setLink(entityLink);
 359
 360     if (!getSearchTags(aaiEventEntity, searchableAttr, uebPayload, action)) {
 361       logger.error(EntityEventPolicyMsgs.DISCARD_EVENT_NONVERBOSE,
 362           "Payload missing searchable attribute for entity type '" + entityType + "'");
 363       logger.debug(EntityEventPolicyMsgs.DISCARD_EVENT_VERBOSE,
 364           "Payload missing searchable attribute for entity type '" + entityType + "'", uebPayload);
 365
 366       setResponse(exchange, ResponseType.FAILURE, additionalInfo);
 367       return;
 368
 369     }
 370
 371     try {
 372       aaiEventEntity.deriveFields();
 373
 374     } catch (NoSuchAlgorithmException e) {
 375       logger.error(EntityEventPolicyMsgs.DISCARD_EVENT_VERBOSE,
 376           "Cannot create unique SHA digest");
 377       logger.debug(EntityEventPolicyMsgs.DISCARD_EVENT_VERBOSE,
 378           "Cannot create unique SHA digest", uebPayload);
 379
 380       setResponse(exchange, ResponseType.FAILURE, additionalInfo);
 381       return;
 382     }
 383
 384     handleSearchServiceOperation(aaiEventEntity, action, entitySearchIndex);
 385
 386     handleTopographicalData(uebPayload, action, entityType, oxmEntityType, oxmJaxbContext,
 387         entityPrimaryKeyFieldName, entityPrimaryKeyFieldValue);
 388
 389     /*
 390      * Use the versioned OXM Entity class to get access to cross-entity reference helper collections
 391      */
 392     VersionedOxmEntities oxmEntities =
 393         EntityOxmReferenceHelper.getInstance().getVersionedOxmEntities(Version.valueOf(oxmVersion.toLowerCase()));
 394
 395     /**
 396      * NOTES:
 397      * 1. If the entity type is "customer", the below check will return true if any nested entityType
 398      * in that model could contain a CER based on the OXM model version that has been loaded.
 399      * 2. For a DELETE operation on outer/parent entity (handled by the regular flow:
 400      * handleSearchServiceOperation()), ignore processing for cross-entity-reference under the
 401      * assumption that AAI will push down all required cascade-deletes for nested entities as well
 402      * 3. Handling the case where UEB events arrive out of order: CREATE customer is received before
 403      *  CREATE service-instance.
 404      */
 405
 406     if (!action.equalsIgnoreCase(ACTION_DELETE) && oxmEntities != null
 407         && oxmEntities.entityModelContainsCrossEntityReference(topEntityType)) {
 408
 409       // We know the model "can" contain a CER reference definition, let's process a bit more
 410
 411       HashMap<String, CrossEntityReference> crossEntityRefMap =
 412           oxmEntities.getCrossEntityReferences();
 413
 414       JSONObject entityJsonObject = getUebEntity(uebPayload);
 415
 416       JsonNode entityJsonNode = convertToJsonNode(entityJsonObject.toString());
 417
 418       String parentEntityType = entityType;
 419
 420       String targetEntityUrl = entityLink;
 421
 422       for (Map.Entry<String, CrossEntityReference> entry : crossEntityRefMap.entrySet()) {
 423
 424         /*
 425          * if we know service-subscription is in the tree, then we can pull our all instances and
 426          * process from there.
 427          */
 428
 429         String key = entry.getKey();
 430         CrossEntityReference cerDescriptor = entry.getValue();
 431
 432         ArrayList<JsonNode> foundNodes = new ArrayList<>();
 433
 434         RouterServiceUtil.extractObjectsByKey(entityJsonNode, key, foundNodes);
 435
 436         if (!foundNodes.isEmpty()) {
 437
 438           for (JsonNode n : foundNodes) {
 439             if ("customer".equalsIgnoreCase(parentEntityType)){
 440               /*
 441                * NOTES:
 442                * 1. prepare to hand-create url for service-instance
 443                * 2. this will break if the URL structure for service-instance changes
 444                */
 445               if (n.has("service-type")){
 446                 targetEntityUrl += "/service-subscriptions/service-subscription/"
 447                     + RouterServiceUtil.getNodeFieldAsText(n, "service-type")
 448                     + "/service-instances/service-instance/";
 449               }
 450
 451             }
 452
 453             List<String> extractedParentEntityAttributeValues = new ArrayList<>();
 454
 455             RouterServiceUtil.extractFieldValuesFromObject(n, cerDescriptor.getAttributeNames(),
 456                 extractedParentEntityAttributeValues);
 457
 458             List<JsonNode> nestedTargetEntityInstances = new ArrayList<>();
 459             RouterServiceUtil.extractObjectsByKey(n, cerDescriptor.getTargetEntityType(),
 460                 nestedTargetEntityInstances);
 461
 462             for (JsonNode targetEntityInstance : nestedTargetEntityInstances) {
 463               /*
 464                * Now:
 465                * 1. build the AAIEntityType (IndexDocument) based on the extract entity
 466                * 2. Get data from ES
 467                * 3. Extract ETAG
 468                * 4. Merge ES Doc + AAIEntityType + Extracted Parent Cross-Entity-Reference Values
 469                * 5. Put data into ES with ETAG + updated doc
 470                */
 471
 472               // Get the complete URL for target entity
 473               if (targetEntityInstance.has("link")) {   // nested SI has url mentioned
 474                 targetEntityUrl = RouterServiceUtil.getNodeFieldAsText(targetEntityInstance,
 475                     "link");
 476               } else if ("customer".equalsIgnoreCase(parentEntityType) &&
 477                   targetEntityInstance.has("service-instance-id")){
 478                 targetEntityUrl += RouterServiceUtil.getNodeFieldAsText(targetEntityInstance,
 479                     "service-instance-id");
 480               }
 481
 482               OxmEntityDescriptor searchableDescriptor =
 483                   oxmEntities.getSearchableEntityDescriptor(cerDescriptor.getTargetEntityType());
 484
 485               if (searchableDescriptor != null) {
 486
 487                 if (!searchableDescriptor.getSearchableAttributes().isEmpty()) {
 488
 489                   AaiEventEntity entityToSync = null;
 490
 491                   try {
 492
 493                     entityToSync = getPopulatedEntity(targetEntityInstance, searchableDescriptor);
 494
 495                     /*
 496                      * Ready to do some ElasticSearch ops
 497                      */
 498
 499                     for (String parentCrossEntityReferenceAttributeValue : extractedParentEntityAttributeValues) {
 500                       entityToSync
 501                           .addCrossEntityReferenceValue(parentCrossEntityReferenceAttributeValue);
 502                     }
 503
 504                     entityToSync.setLink(targetEntityUrl);
 505                     entityToSync.deriveFields();
 506
 507                     updateCerInEntity(entityToSync);
 508
 509                   } catch (NoSuchAlgorithmException e) {
 510                     logger.debug(e.getMessage());
 511                   }
 512                 }
 513               } else {
 514                 logger.debug(EntityEventPolicyMsgs.CROSS_ENTITY_REFERENCE_SYNC,
 515                     "failure to find searchable descriptor for type "
 516                         + cerDescriptor.getTargetEntityType());
 517               }
 518             }
 519
 520           }
 521
 522         } else {
 523           logger.debug(EntityEventPolicyMsgs.CROSS_ENTITY_REFERENCE_SYNC,
 524               "failed to find 0 instances of cross-entity-reference with entity " + key);
 525         }
 526
 527       }
 528
 529     } else {
 530       logger.info(EntityEventPolicyMsgs.CROSS_ENTITY_REFERENCE_SYNC, "skipped due to OXM model for "
 531           + topEntityType + " does not contain a cross-entity-reference entity");
 532     }
 533
 534     /*
 535      * Process for autosuggestable entities
 536      */
 537     if (oxmEntities != null) {
 538       Map<String, OxmEntityDescriptor> rootDescriptor =
 539           oxmEntities.getSuggestableEntityDescriptors();
 540       if (!rootDescriptor.isEmpty()) {
 541         List<String> suggestibleAttrInPayload = new ArrayList<>();
 542         List<String> suggestibleAttrInOxm = extractSuggestableAttr(oxmEntities, entityType);
 543         if (suggestibleAttrInOxm != null) {
 544           for (String attr: suggestibleAttrInOxm){
 545             if ( uebObjEntity.has(attr) ){
 546               suggestibleAttrInPayload.add(attr);
 547             }
 548           }
 549         }
 550
 551         if (suggestibleAttrInPayload.isEmpty()) {
 552           return;
 553         }
 554
 555         List<String> suggestionAliases = extractAliasForSuggestableEntity(oxmEntities, entityType);
 556         AggregationEntity ae = new AggregationEntity();
 557         ae.setLink(entityLink);
 558         ae.deriveFields(uebAsJson);
 559
 560         handleSearchServiceOperation(ae, action, aggregateGenericVnfIndex);
 561
 562         /*
 563          * It was decided to silently ignore DELETE requests for resources we don't allow to be
 564          * deleted. e.g. auto-suggestion deletion is not allowed while aggregation deletion is.
 565          */
 566         if (!ACTION_DELETE.equalsIgnoreCase(action)) {
 567           List<ArrayList<String>> listOfValidPowerSetElements =
 568               SearchSuggestionPermutation.getNonEmptyUniqueLists(suggestibleAttrInPayload);
 569
 570           // Now we have a list containing the power-set (minus empty element) for the status that are
 571           // available in the payload. Try inserting a document for every combination.
 572           for (ArrayList<String> list : listOfValidPowerSetElements) {
 573             SuggestionSearchEntity suggestionSearchEntity = new SuggestionSearchEntity();
 574             suggestionSearchEntity.setEntityType(entityType);
 575             suggestionSearchEntity.setSuggestableAttr(list);
 576             suggestionSearchEntity.setEntityTypeAliases(suggestionAliases);
 577             suggestionSearchEntity.setFilterBasedPayloadFromResponse(uebAsJson.get("entity"),
 578                 suggestibleAttrInOxm, list);
 579             suggestionSearchEntity.setSuggestionInputPermutations(
 580                 suggestionSearchEntity.generateSuggestionInputPermutations());
 581
 582             if (suggestionSearchEntity.isSuggestableDoc()) {
 583               try {
 584                 suggestionSearchEntity.generateSearchSuggestionDisplayStringAndId();
 585               } catch (NoSuchAlgorithmException e) {
 586                 logger.error(EntityEventPolicyMsgs.DISCARD_UPDATING_SEARCH_SUGGESTION_DATA,
 587                     "Cannot create unique SHA digest for search suggestion data. Exception: "
 588                         + e.getLocalizedMessage());
 589               }
 590
 591               handleSearchServiceOperation(suggestionSearchEntity, action, autosuggestIndex);
 592             }
 593           }
 594         }
 595       }
 596     }
 597
 598     long stopTime = System.currentTimeMillis();
 599
 600     metricsLogger.info(EntityEventPolicyMsgs.OPERATION_RESULT_NO_ERRORS, PROCESS_AAI_EVENT,
 601         String.valueOf(stopTime - startTime));
 602
 603     setResponse(exchange, ResponseType.SUCCESS, additionalInfo);
 604     return;
 605   }
 606
 607   public List<String> extractSuggestableAttr(VersionedOxmEntities oxmEntities, String entityType) {
 608     // Extract suggestable attributeshandleTopographicalData
 609     Map<String, OxmEntityDescriptor> rootDescriptor = oxmEntities.getSuggestableEntityDescriptors();
 610
 611     if (rootDescriptor == null) {
 612       return Collections.emptyList();
 613     }
 614
 615     OxmEntityDescriptor desc = rootDescriptor.get(entityType);
 616
 617     if (desc == null) {
 618       return Collections.emptyList();
 619     }
 620
 621     return desc.getSuggestableAttributes();
 622   }
 623
 624   public List<String> extractAliasForSuggestableEntity(VersionedOxmEntities oxmEntities,
 625       String entityType) {
 626
 627     // Extract alias
 628     Map<String, OxmEntityDescriptor> rootDescriptor = oxmEntities.getEntityAliasDescriptors();
 629
 630     if (rootDescriptor == null) {
 631       return Collections.emptyList();
 632     }
 633
 634     OxmEntityDescriptor desc = rootDescriptor.get(entityType);
 635     return desc.getAlias();
 636   }
 637
 638   private void setResponse(Exchange exchange, ResponseType responseType, String additionalInfo) {
 639
 640     exchange.getOut().setHeader("ResponseType", responseType.toString());
 641     exchange.getOut().setBody(additionalInfo);
 642   }
 643
 644   public void extractDetailsForAutosuggestion(VersionedOxmEntities oxmEntities, String entityType,
 645       List<String> suggestableAttr, List<String> alias) {
 646
 647     // Extract suggestable attributes
 648     Map<String, OxmEntityDescriptor> rootDescriptor = oxmEntities.getSuggestableEntityDescriptors();
 649
 650     OxmEntityDescriptor desc = rootDescriptor.get(entityType);
 651     suggestableAttr = desc.getSuggestableAttributes();
 652
 653     // Extract alias
 654     rootDescriptor = oxmEntities.getEntityAliasDescriptors();
 655     desc = rootDescriptor.get(entityType);
 656     alias = desc.getAlias();
 657   }
 658
 659   /*
 660    * Load the UEB JSON payload, any errors would result to a failure case response.
 661    */
 662   private JSONObject getUebContentAsJson(String payload, String contentKey) {
 663
 664     JSONObject uebJsonObj;
 665     JSONObject uebObjContent;
 666
 667     try {
 668       uebJsonObj = new JSONObject(payload);
 669     } catch (JSONException e) {
 670       logger.debug(EntityEventPolicyMsgs.UEB_INVALID_PAYLOAD_JSON_FORMAT, payload);
 671       logger.error(EntityEventPolicyMsgs.UEB_INVALID_PAYLOAD_JSON_FORMAT, payload);
 672       return null;
 673     }
 674
 675     if (uebJsonObj.has(contentKey)) {
 676       uebObjContent = uebJsonObj.getJSONObject(contentKey);
 677     } else {
 678       logger.debug(EntityEventPolicyMsgs.UEB_FAILED_TO_PARSE_PAYLOAD, contentKey);
 679       logger.error(EntityEventPolicyMsgs.UEB_FAILED_TO_PARSE_PAYLOAD, contentKey);
 680       return null;
 681     }
 682
 683     return uebObjContent;
 684   }
 685
 686
 687   private UebEventHeader initializeUebEventHeader(String payload) {
 688
 689     UebEventHeader eventHeader = null;
 690     ObjectMapper mapper = new ObjectMapper();
 691
 692     // Make sure that were were actually passed in a valid string.
 693     if (payload == null || payload.isEmpty()) {
 694       logger.debug(EntityEventPolicyMsgs.UEB_FAILED_TO_PARSE_PAYLOAD, EVENT_HEADER);
 695       logger.error(EntityEventPolicyMsgs.UEB_FAILED_TO_PARSE_PAYLOAD, EVENT_HEADER);
 696
 697       return eventHeader;
 698     }
 699
 700     // Marshal the supplied string into a UebEventHeader object.
 701     try {
 702       eventHeader = mapper.readValue(payload, UebEventHeader.class);
 703     } catch (JsonProcessingException e) {
 704       logger.error(EntityEventPolicyMsgs.UEB_FAILED_UEBEVENTHEADER_CONVERSION, e.toString());
 705     } catch (Exception e) {
 706       logger.error(EntityEventPolicyMsgs.UEB_FAILED_UEBEVENTHEADER_CONVERSION, e.toString());
 707     }
 708
 709     if (eventHeader != null) {
 710       logger.debug(EntityEventPolicyMsgs.UEB_EVENT_HEADER_PARSED, eventHeader.toString());
 711     }
 712
 713     return eventHeader;
 714
 715   }
 716
 717
 718   private String getEntityPrimaryKeyFieldName(DynamicJAXBContext oxmJaxbContext, String payload,
 719       String oxmEntityType, String entityType) {
 720
 721     DynamicType entity = oxmJaxbContext.getDynamicType(oxmEntityType);
 722     if (entity == null) {
 723       return null;
 724     }
 725
 726     List<DatabaseField> list = entity.getDescriptor().getPrimaryKeyFields();
 727     if (list != null && !list.isEmpty()) {
 728       String keyName = list.get(0).getName();
 729       return keyName.substring(0, keyName.indexOf('/'));
 730     }
 731
 732     return "";
 733   }
 734
 735   private String lookupValueUsingKey(String payload, String key) throws JSONException {
 736     JsonNode jsonNode = convertToJsonNode(payload);
 737     return RouterServiceUtil.recursivelyLookupJsonPayload(jsonNode, key);
 738   }
 739
 740   private JsonNode convertToJsonNode(String payload) {
 741
 742     ObjectMapper mapper = new ObjectMapper();
 743     JsonNode jsonNode = null;
 744     try {
 745       jsonNode = mapper.readTree(mapper.getJsonFactory().createJsonParser(payload));
 746     } catch (IOException e) {
 747       logger.debug(EntityEventPolicyMsgs.FAILED_TO_PARSE_UEB_PAYLOAD, ENTITY_HEADER + " missing",
 748           payload);
 749       logger.error(EntityEventPolicyMsgs.FAILED_TO_PARSE_UEB_PAYLOAD, ENTITY_HEADER + " missing",
 750           "");
 751     }
 752
 753     return jsonNode;
 754   }
 755
 756   private boolean getSearchTags(AaiEventEntity aaiEventEntity, List<String> searchableAttr,
 757       String payload, String action) {
 758
 759     boolean hasSearchableAttr = false;
 760     for (String searchTagField : searchableAttr) {
 761       String searchTagValue;
 762       if (searchTagField.equalsIgnoreCase(aaiEventEntity.getEntityPrimaryKeyName())) {
 763         searchTagValue = aaiEventEntity.getEntityPrimaryKeyValue();
 764       } else {
 765         searchTagValue = this.lookupValueUsingKey(payload, searchTagField);
 766       }
 767
 768       if (searchTagValue != null && !searchTagValue.isEmpty()) {
 769         hasSearchableAttr = true;
 770         aaiEventEntity.addSearchTagWithKey(searchTagValue, searchTagField);
 771       }
 772     }
 773     return hasSearchableAttr;
 774   }
 775
 776   /*
 777    * Check if OXM version is available. If available, load it.
 778    */
 779   private DynamicJAXBContext loadOxmContext(String version) {
 780     if (version == null) {
 781       logger.error(EntityEventPolicyMsgs.FAILED_TO_FIND_OXM_VERSION, version);
 782       return null;
 783     }
 784
 785     return oxmVersionContextMap.get(version);
 786   }
 787
 788   private List<String> getOxmAttributes(String payload, DynamicJAXBContext oxmJaxbContext,
 789       String oxmEntityType, String entityType, String fieldName) {
 790
 791     DynamicType entity = (DynamicType) oxmJaxbContext.getDynamicType(oxmEntityType);
 792     if (entity == null) {
 793       return null;
 794     }
 795
 796     /*
 797      * Check for searchable XML tag
 798      */
 799     List<String> fieldValues = null;
 800     Map<String, String> properties = entity.getDescriptor().getProperties();
 801     for (Map.Entry<String, String> entry : properties.entrySet()) {
 802       if (entry.getKey().equalsIgnoreCase(fieldName)) {
 803         fieldValues = Arrays.asList(entry.getValue().split(","));
 804         break;
 805       }
 806     }
 807
 808     return fieldValues;
 809   }
 810
 811   private JSONObject getUebEntity(String payload) {
 812     JSONObject uebJsonObj;
 813
 814     try {
 815       uebJsonObj = new JSONObject(payload);
 816     } catch (JSONException e) {
 817       logger.debug(EntityEventPolicyMsgs.DISCARD_EVENT_VERBOSE,
 818           "Payload has invalid JSON Format", payload);
 819       logger.error(EntityEventPolicyMsgs.DISCARD_EVENT_NONVERBOSE,
 820           "Payload has invalid JSON Format");
 821       return null;
 822     }
 823
 824     if (uebJsonObj.has(ENTITY_HEADER)) {
 825       return uebJsonObj.getJSONObject(ENTITY_HEADER);
 826     } else {
 827       logger.debug(EntityEventPolicyMsgs.FAILED_TO_PARSE_UEB_PAYLOAD, ENTITY_HEADER + " missing", payload);
 828       logger.error(EntityEventPolicyMsgs.FAILED_TO_PARSE_UEB_PAYLOAD, ENTITY_HEADER + " missing");
 829       return null;
 830     }
 831   }
 832
 833   protected AaiEventEntity getPopulatedEntity(JsonNode entityNode,
 834       OxmEntityDescriptor resultDescriptor) {
 835     AaiEventEntity d = new AaiEventEntity();
 836
 837     d.setEntityType(resultDescriptor.getEntityName());
 838
 839     List<String> primaryKeyValues = new ArrayList<>();
 840     List<String> primaryKeyNames = new ArrayList<>();
 841     String pkeyValue;
 842
 843     for (String keyName : resultDescriptor.getPrimaryKeyAttributeName()) {
 844       pkeyValue = RouterServiceUtil.getNodeFieldAsText(entityNode, keyName);
 845       if (pkeyValue != null) {
 846         primaryKeyValues.add(pkeyValue);
 847         primaryKeyNames.add(keyName);
 848       } else {
 849         logger.error(EntityEventPolicyMsgs.PRIMARY_KEY_NULL_FOR_ENTITY_TYPE,
 850             resultDescriptor.getEntityName());
 851       }
 852     }
 853
 854     final String primaryCompositeKeyValue = RouterServiceUtil.concatArray(primaryKeyValues, "/");
 855     d.setEntityPrimaryKeyValue(primaryCompositeKeyValue);
 856     final String primaryCompositeKeyName = RouterServiceUtil.concatArray(primaryKeyNames, "/");
 857     d.setEntityPrimaryKeyName(primaryCompositeKeyName);
 858
 859     final List<String> searchTagFields = resultDescriptor.getSearchableAttributes();
 860
 861     /*
 862      * Based on configuration, use the configured field names for this entity-Type to build a
 863      * multi-value collection of search tags for elastic search entity search criteria.
 864      */
 865
 866
 867     for (String searchTagField : searchTagFields) {
 868       String searchTagValue = RouterServiceUtil.getNodeFieldAsText(entityNode, searchTagField);
 869       if (searchTagValue != null && !searchTagValue.isEmpty()) {
 870         d.addSearchTagWithKey(searchTagValue, searchTagField);
 871       }
 872     }
 873
 874     return d;
 875   }
 876
 877   private void updateCerInEntity(AaiEventEntity aaiEventEntity) {
 878     try {
 879       Map<String, List<String>> headers = new HashMap<>();
 880       headers.put(Headers.FROM_APP_ID, Arrays.asList("Data Router"));
 881       headers.put(Headers.TRANSACTION_ID, Arrays.asList(MDC.get(MdcContext.MDC_REQUEST_ID)));
 882
 883       String entityId = aaiEventEntity.getId();
 884       String jsonPayload;
 885
 886       // Run the GET to retrieve the ETAG from the search service
 887       OperationResult storedEntity = searchAgent.getDocument(entitySearchIndex, entityId);
 888
 889       if (HttpUtil.isHttpResponseClassSuccess(storedEntity.getResultCode())) {
 890         /*
 891          * NOTES: aaiEventEntity (ie the nested entity) may contain a subset of properties of
 892          * the pre-existing object,
 893          * so all we want to do is update the CER on the pre-existing object (if needed).
 894          */
 895
 896         List<String> etag = storedEntity.getHeaders().get(Headers.ETAG);
 897
 898         if (etag != null && !etag.isEmpty()) {
 899           headers.put(Headers.IF_MATCH, etag);
 900         } else {
 901           logger.error(EntityEventPolicyMsgs.NO_ETAG_AVAILABLE_FAILURE,
 902                   entitySearchIndex, entityId);
 903         }
 904
 905         ArrayList<JsonNode> sourceObject = new ArrayList<>();
 906         NodeUtils.extractObjectsByKey(
 907             NodeUtils.convertJsonStrToJsonNode(storedEntity.getResult()),
 908             "content", sourceObject);
 909
 910         if (!sourceObject.isEmpty()) {
 911           JsonNode node = sourceObject.get(0);
 912           final String sourceCer = NodeUtils.extractFieldValueFromObject(node,
 913               "crossEntityReferenceValues");
 914           String newCer = aaiEventEntity.getCrossReferenceEntityValues();
 915           boolean hasNewCer = true;
 916           if (sourceCer != null && sourceCer.length() > 0){ // already has CER
 917             if ( !sourceCer.contains(newCer)){//don't re-add
 918               newCer = sourceCer + ";" + newCer;
 919             } else {
 920               hasNewCer = false;
 921             }
 922           }
 923
 924           if (hasNewCer){
 925             // Do the PUT with new CER
 926             ((ObjectNode)node).put("crossEntityReferenceValues", newCer);
 927             jsonPayload = NodeUtils.convertObjectToJson(node, false);
 928             searchAgent.putDocument(entitySearchIndex, entityId, jsonPayload, headers);
 929           }
 930          }
 931       } else {
 932
 933         if (storedEntity.getResultCode() == 404) {
 934           // entity not found, so attempt to do a PUT
 935           searchAgent.putDocument(entitySearchIndex, entityId, aaiEventEntity.getAsJson(), headers);
 936         } else {
 937           logger.error(EntityEventPolicyMsgs.FAILED_TO_UPDATE_ENTITY_IN_DOCSTORE,
 938               aaiEventEntity.getId(), "SYNC_ENTITY");
 939         }
 940       }
 941     } catch (IOException e) {
 942       logger.error(EntityEventPolicyMsgs.FAILED_TO_UPDATE_ENTITY_IN_DOCSTORE,
 943           aaiEventEntity.getId(), "SYNC_ENTITY");
 944     }
 945   }
 946
 947   /**
 948    * Perform create, read, update or delete (CRUD) operation on search engine's suggestive search
 949    * index
 950    *
 951    * @param eventEntity Entity/data to use in operation
 952    * @param action The operation to perform
 953    * @param target Resource to perform the operation on
 954    * @param allowDeleteEvent Allow delete operation to be performed on resource
 955    */
 956   protected void handleSearchServiceOperation(DocumentStoreDataEntity eventEntity,
 957                                             String                  action,
 958                                             String                  index) {
 959     try {
 960
 961       Map<String, List<String>> headers = new HashMap<>();
 962       headers.put(Headers.FROM_APP_ID, Arrays.asList("DataLayer"));
 963       headers.put(Headers.TRANSACTION_ID, Arrays.asList(MDC.get(MdcContext.MDC_REQUEST_ID)));
 964
 965       String entityId = eventEntity.getId();
 966
 967       if ((action.equalsIgnoreCase(ACTION_CREATE) && entityId != null)
 968           || action.equalsIgnoreCase(ACTION_UPDATE)) {
 969
 970         // Run the GET to retrieve the ETAG from the search service
 971         OperationResult storedEntity = searchAgent.getDocument(index, entityId);
 972
 973         if (HttpUtil.isHttpResponseClassSuccess(storedEntity.getResultCode())) {
 974           List<String> etag = storedEntity.getHeaders().get(Headers.ETAG);
 975
 976           if (etag != null && !etag.isEmpty()) {
 977             headers.put(Headers.IF_MATCH, etag);
 978           } else {
 979             logger.error(EntityEventPolicyMsgs.NO_ETAG_AVAILABLE_FAILURE, index,
 980                 entityId);
 981           }
 982         }
 983
 984         // Write the entity to the search service.
 985         // PUT
 986         searchAgent.putDocument(index, entityId, eventEntity.getAsJson(), headers);
 987       } else if (action.equalsIgnoreCase(ACTION_CREATE)) {
 988         // Write the entry to the search service.
 989         searchAgent.postDocument(index, eventEntity.getAsJson(), headers);
 990
 991       } else if (action.equalsIgnoreCase(ACTION_DELETE)) {
 992         // Run the GET to retrieve the ETAG from the search service
 993         OperationResult storedEntity = searchAgent.getDocument(index, entityId);
 994
 995         if (HttpUtil.isHttpResponseClassSuccess(storedEntity.getResultCode())) {
 996           List<String> etag = storedEntity.getHeaders().get(Headers.ETAG);
 997
 998           if (etag != null && !etag.isEmpty()) {
 999             headers.put(Headers.IF_MATCH, etag);
1000           } else {
1001             logger.error(EntityEventPolicyMsgs.NO_ETAG_AVAILABLE_FAILURE, index,
1002                 entityId);
1003           }
1004
1005           /*
1006            * The Spring-Boot version of the search-data-service rejects the DELETE operation unless
1007            * we specify a Content-Type.
1008            */
1009
1010           headers.put("Content-Type", Arrays.asList(MediaType.APPLICATION_JSON.getMediaType()));
1011
1012           searchAgent.deleteDocument(index, eventEntity.getId(), headers);
1013         } else {
1014           logger.error(EntityEventPolicyMsgs.NO_ETAG_AVAILABLE_FAILURE, index,
1015               entityId);
1016         }
1017       } else {
1018         logger.error(EntityEventPolicyMsgs.ENTITY_OPERATION_NOT_SUPPORTED, action);
1019       }
1020     } catch (IOException e) {
1021       logger.error(EntityEventPolicyMsgs.FAILED_TO_UPDATE_ENTITY_IN_DOCSTORE, eventEntity.getId(),
1022           action);
1023     }
1024   }
1025
1026   private void handleTopographicalData(String payload, String action, String entityType,
1027       String oxmEntityType, DynamicJAXBContext oxmJaxbContext, String entityPrimaryKeyFieldName,
1028       String entityPrimaryKeyFieldValue) {
1029
1030     Map<String, String> topoData = new HashMap<>();
1031     String entityLink;
1032     List<String> topographicalAttr =
1033         getOxmAttributes(payload, oxmJaxbContext, oxmEntityType, entityType, "geoProps");
1034     if (topographicalAttr == null) {
1035       logger.error(EntityEventPolicyMsgs.DISCARD_UPDATING_TOPOGRAPHY_DATA_NONVERBOSE,
1036           "Topograhical attribute not found for payload entity type '" + entityType + "'");
1037       logger.debug(EntityEventPolicyMsgs.DISCARD_UPDATING_TOPOGRAPHY_DATA_VERBOSE,
1038           "Topograhical attribute not found for payload entity type '" + entityType + "'",
1039           payload);
1040     } else {
1041       entityLink = lookupValueUsingKey(payload, "entity-link");
1042       for (String topoAttr : topographicalAttr) {
1043         topoData.put(topoAttr, lookupValueUsingKey(payload, topoAttr));
1044       }
1045       updateTopographicalSearchDb(topoData, entityType, action, entityPrimaryKeyFieldName,
1046           entityPrimaryKeyFieldValue, entityLink);
1047     }
1048
1049   }
1050
1051   private void updateTopographicalSearchDb(Map<String, String> topoData, String entityType,
1052       String action, String entityPrimaryKeyName, String entityPrimaryKeyValue, String entityLink) {
1053
1054     TopographicalEntity topoEntity = new TopographicalEntity();
1055     topoEntity.setEntityPrimaryKeyName(entityPrimaryKeyName);
1056     topoEntity.setEntityPrimaryKeyValue(entityPrimaryKeyValue);
1057     topoEntity.setEntityType(entityType);
1058     topoEntity.setLatitude(topoData.get(TOPO_LAT));
1059     topoEntity.setLongitude(topoData.get(TOPO_LONG));
1060     topoEntity.setSelfLink(entityLink);
1061     try {
1062       topoEntity.setId(TopographicalEntity.generateUniqueShaDigest(entityType, entityPrimaryKeyName,
1063           entityPrimaryKeyValue));
1064     } catch (NoSuchAlgorithmException e) {
1065       logger.error(EntityEventPolicyMsgs.DISCARD_UPDATING_TOPOGRAPHY_DATA_VERBOSE,
1066           "Cannot create unique SHA digest for topographical data.");
1067     }
1068
1069     this.handleSearchServiceOperation(topoEntity, action, topographicalSearchIndex);
1070   }
1071
1072
1073   // put this here until we find a better spot
1074   /**
1075    * Helper utility to concatenate substrings of a URI together to form a proper URI.
1076    *
1077    * @param suburis the list of substrings to concatenate together
1078    * @return the concatenated list of substrings
1079    */
1080   public static String concatSubUri(String... suburis) {
1081     String finalUri = "";
1082
1083     for (String suburi : suburis) {
1084
1085       if (suburi != null) {
1086         // Remove any leading / since we only want to append /
1087         suburi = suburi.replaceFirst("^/*", "");
1088
1089         // Add a trailing / if one isn't already there
1090         finalUri += suburi.endsWith("/") ? suburi : suburi + "/";
1091       }
1092     }
1093
1094     return finalUri;
1095   }
1096 }