blueprints-processor/plugin/model-provider/src/main/java/org/onap/ccsdk/features/model/utils/ResourceAssignmentUtils.java

   1 /*\r
   2  * Copyright © 2017-2018 AT&T Intellectual Property.\r
   3  * Modifications Copyright © 2018 IBM.\r
   4  * \r
   5  * Licensed under the Apache License, Version 2.0 (the "License");\r
   6  * you may not use this file except in compliance with the License.\r
   7  * You may obtain a copy of the License at\r
   8  * \r
   9  * http://www.apache.org/licenses/LICENSE-2.0\r
  10  * \r
  11  * Unless required by applicable law or agreed to in writing, software\r
  12  * distributed under the License is distributed on an "AS IS" BASIS,\r
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  14  * See the License for the specific language governing permissions and\r
  15  * limitations under the License.\r
  16  */\r
  17 \r
  18 package org.onap.ccsdk.features.model.utils;\r
  19 \r
  20 import java.util.Date;\r
  21 import java.util.HashSet;\r
  22 import java.util.List;\r
  23 import java.util.Map;\r
  24 import java.util.Set;\r
  25 import org.apache.commons.lang3.BooleanUtils;\r
  26 import org.apache.commons.lang3.StringUtils;\r
  27 import org.onap.ccsdk.features.model.ConfigModelConstant;\r
  28 import org.onap.ccsdk.features.model.ConfigModelException;\r
  29 import org.onap.ccsdk.features.model.ValidTypes;\r
  30 import org.onap.ccsdk.features.model.data.ResourceAssignment;\r
  31 import org.onap.ccsdk.features.model.data.dict.ResourceDefinition;\r
  32 \r
  33 import com.att.eelf.configuration.EELFLogger;\r
  34 import com.att.eelf.configuration.EELFManager;\r
  35 import com.fasterxml.jackson.databind.JsonNode;\r
  36 import com.fasterxml.jackson.databind.ObjectMapper;\r
  37 import com.fasterxml.jackson.databind.node.ArrayNode;\r
  38 import com.fasterxml.jackson.databind.node.NullNode;\r
  39 import com.fasterxml.jackson.databind.node.ObjectNode;\r
  40 import com.google.common.base.Preconditions;\r
  41 \r
  42 public class ResourceAssignmentUtils {\r
  43 \r
  44     private ResourceAssignmentUtils() {\r
  45 \r
  46     }\r
  47 \r
  48     private static EELFLogger logger = EELFManager.getInstance().getLogger(ResourceAssignmentUtils.class);\r
  49 \r
  50     public static String getArtifactNodeContent(String nodeTemplateName, Map<String, Object> context) {\r
  51         Preconditions.checkArgument(StringUtils.isNotBlank(nodeTemplateName),\r
  52                 "getArtifactNodeContent missing template name");\r
  53         return (String) context.get(ConfigModelConstant.PROPERTY_NODE_TEMPLATES_DOT + nodeTemplateName + ".content");\r
  54     }\r
  55 \r
  56     public static List<ResourceAssignment> getArtifactNodeMapping(String nodeTemplateName,\r
  57             Map<String, Object> context) {\r
  58         Preconditions.checkArgument(StringUtils.isNotBlank(nodeTemplateName),\r
  59                 "getArtifactNodeMapping missing template name");\r
  60         List<ResourceAssignment> resourceAssignments = null;\r
  61         String resourceMappingContent =\r
  62                 (String) context.get(ConfigModelConstant.PROPERTY_NODE_TEMPLATES_DOT + nodeTemplateName + ".mapping");\r
  63         if (StringUtils.isNotBlank(resourceMappingContent)) {\r
  64             resourceAssignments = TransformationUtils.getListfromJson(resourceMappingContent, ResourceAssignment.class);\r
  65 \r
  66         } else {\r
  67             logger.warn("missing mapping content for node template ({})", nodeTemplateName);\r
  68         }\r
  69         return resourceAssignments;\r
  70     }\r
  71 \r
  72     // Not used Any whre\r
  73     public static synchronized void cleanContextTemplateNDictionaryKeys(Map<String, Object> componentContext) {\r
  74         String recipeName = (String) componentContext.get(ConfigModelConstant.PROPERTY_ACTION_NAME);\r
  75         Set<String> removeSet = new HashSet<>();\r
  76         componentContext.forEach((key, value) -> {\r
  77             if (StringUtils.isNotBlank(key)\r
  78                     && (key.startsWith(ConfigModelConstant.PROPERTY_DICTIONARY_KEY_DOT + recipeName + ".")\r
  79                             || key.startsWith(ConfigModelConstant.PROPERTY_RECIPE_KEY_DOT + recipeName + "."))) {\r
  80                 removeSet.add(key);\r
  81             }\r
  82         });\r
  83         componentContext.keySet().removeAll(removeSet);\r
  84     }\r
  85 \r
  86     public static synchronized Object getDictionaryKeyValue(Map<String, Object> componentContext,\r
  87             ResourceAssignment resourceMapping) {\r
  88         Object value = null;\r
  89         if (resourceMapping != null && componentContext != null) {\r
  90             String recipeName = (String) componentContext.get(ConfigModelConstant.PROPERTY_ACTION_NAME);\r
  91             String dictionaryKeyName = resourceMapping.getDictionaryName();\r
  92             value = componentContext\r
  93                     .get(ConfigModelConstant.PROPERTY_DICTIONARY_KEY_DOT + recipeName + "." + dictionaryKeyName);\r
  94         }\r
  95         return value;\r
  96     }\r
  97 \r
  98     public static synchronized Object getDictionaryKeyValue(Map<String, Object> componentContext,\r
  99             ResourceDefinition resourceDictionary) {\r
 100         Object value = null;\r
 101         if (resourceDictionary != null && componentContext != null) {\r
 102             String recipeName = (String) componentContext.get(ConfigModelConstant.PROPERTY_ACTION_NAME);\r
 103             String dictionaryKeyName = resourceDictionary.getName();\r
 104             value = componentContext\r
 105                     .get(ConfigModelConstant.PROPERTY_DICTIONARY_KEY_DOT + recipeName + "." + dictionaryKeyName);\r
 106         }\r
 107         return value;\r
 108     }\r
 109 \r
 110     public static synchronized Object getTemplateKeyValue(Map<String, Object> componentContext,\r
 111             ResourceAssignment resourceMapping) {\r
 112         Object value = null;\r
 113         if (resourceMapping != null && componentContext != null) {\r
 114             String recipeName = (String) componentContext.get(ConfigModelConstant.PROPERTY_ACTION_NAME);\r
 115             String templateKeyName = resourceMapping.getName();\r
 116             value = componentContext\r
 117                     .get(ConfigModelConstant.PROPERTY_RECIPE_KEY_DOT + recipeName + "." + templateKeyName);\r
 118         }\r
 119         return value;\r
 120     }\r
 121 \r
 122     public static synchronized void setResourceDataValue(Map<String, Object> componentContext,\r
 123             ResourceAssignment resourceAssignment, Object value) throws ConfigModelException {\r
 124 \r
 125         if (resourceAssignment != null && StringUtils.isNotBlank(resourceAssignment.getName())\r
 126                 && resourceAssignment.getProperty() != null) {\r
 127 \r
 128             String recipeName = (String) componentContext.get(ConfigModelConstant.PROPERTY_ACTION_NAME);\r
 129             String templateKeyName = resourceAssignment.getName();\r
 130             String dictionaryKeyName = resourceAssignment.getDictionaryName();\r
 131 \r
 132             if (StringUtils.isBlank(dictionaryKeyName)) {\r
 133                 resourceAssignment.setDictionaryName(templateKeyName);\r
 134                 dictionaryKeyName = templateKeyName;\r
 135                 logger.warn("Missing dictionary key, setting with template key ({}) as dictionary key ({})",\r
 136                         templateKeyName, dictionaryKeyName);\r
 137             }\r
 138             String type = resourceAssignment.getProperty().getType();\r
 139             try {\r
 140                 if (StringUtils.isNotBlank(type)) {\r
 141                     Object convertedValue = convertResourceValue(type, value);\r
 142 \r
 143                     componentContext.put(\r
 144                             ConfigModelConstant.PROPERTY_DICTIONARY_KEY_DOT + recipeName + "." + dictionaryKeyName,\r
 145                             convertedValue);\r
 146                     componentContext.put(\r
 147                             ConfigModelConstant.PROPERTY_RECIPE_KEY_DOT + recipeName + "." + templateKeyName,\r
 148                             convertedValue);\r
 149 \r
 150                     logger.trace("Setting Resource Value ({}) for Resource Name ({}) of type ({}) ", convertedValue,\r
 151                             dictionaryKeyName, type);\r
 152 \r
 153                     resourceAssignment.getProperty().setValue(convertedValue);\r
 154                     resourceAssignment.setUpdatedDate(new Date());\r
 155                     resourceAssignment.setUpdatedBy(ConfigModelConstant.USER_SYSTEM);\r
 156                     resourceAssignment.setStatus(ConfigModelConstant.STATUS_SUCCESS);\r
 157                 }\r
 158             } catch (Exception e) {\r
 159                 throw new ConfigModelException(String.format(\r
 160                         "Failed in setting value for template key (%s) and dictionary key (%s) of type (%s) with error message (%s)",\r
 161                         templateKeyName, dictionaryKeyName, type, e.getMessage()));\r
 162             }\r
 163         } else {\r
 164             throw new ConfigModelException(\r
 165                     String.format("Failed in setting resource value for resource mapping (%s)", resourceAssignment));\r
 166         }\r
 167     }\r
 168 \r
 169     private static Object convertResourceValue(String type, Object value) {\r
 170         Object convertedValue = null;\r
 171 \r
 172         if (value == null || value instanceof NullNode) {\r
 173             logger.info("Returning {} value from convertResourceValue", value);\r
 174             return null;\r
 175         }\r
 176 \r
 177         if (ValidTypes.getPrimitivePropertType().contains(type)) {\r
 178             convertedValue = convertPrimitiveResourceValue(type, value);\r
 179         } else {\r
 180             // Case where Resource is non-primitive type\r
 181             if (value instanceof JsonNode || value instanceof ObjectNode || value instanceof ArrayNode) {\r
 182                 convertedValue = value;\r
 183             } else if (value instanceof String) {\r
 184                 convertedValue = TransformationUtils.getJsonNodeForString((String) value);\r
 185             } else {\r
 186                 convertedValue = TransformationUtils.getJsonNodeForObject(value);\r
 187             }\r
 188         }\r
 189         return convertedValue;\r
 190     }\r
 191 \r
 192     @SuppressWarnings("squid:S3776")\r
 193     private static Object convertPrimitiveResourceValue(String type, Object value) {\r
 194         Object convertedValue = value;\r
 195 \r
 196         if (value instanceof ArrayNode) {\r
 197             if (ValidTypes.DATA_TYPE_BOOLEAN.equalsIgnoreCase(type)) {\r
 198                 convertedValue = ((ArrayNode) value).asBoolean();\r
 199             } else if (ValidTypes.DATA_TYPE_INTEGER.equalsIgnoreCase(type)) {\r
 200                 convertedValue = ((ArrayNode) value).asInt();\r
 201             } else if (ValidTypes.DATA_TYPE_FLOAT.equalsIgnoreCase(type)) {\r
 202                 convertedValue = Float.valueOf(((ArrayNode) value).toString());\r
 203             } else {\r
 204                 convertedValue = ((ArrayNode) value).toString();\r
 205             }\r
 206         } else if (value instanceof JsonNode) {\r
 207             if (ValidTypes.DATA_TYPE_BOOLEAN.equalsIgnoreCase(type)) {\r
 208                 convertedValue = ((JsonNode) value).asBoolean();\r
 209             } else if (ValidTypes.DATA_TYPE_INTEGER.equalsIgnoreCase(type)) {\r
 210                 convertedValue = ((JsonNode) value).asInt();\r
 211             } else if (ValidTypes.DATA_TYPE_FLOAT.equalsIgnoreCase(type)) {\r
 212                 convertedValue = Float.valueOf(((JsonNode) value).asText());\r
 213             } else {\r
 214                 convertedValue = ((JsonNode) value).asText();\r
 215             }\r
 216         } else if (value instanceof String) {\r
 217             if (ValidTypes.DATA_TYPE_BOOLEAN.equalsIgnoreCase(type)) {\r
 218                 convertedValue = Boolean.valueOf((String) value);\r
 219             } else if (ValidTypes.DATA_TYPE_INTEGER.equalsIgnoreCase(type)) {\r
 220                 convertedValue = Integer.valueOf((String) value);\r
 221             } else if (ValidTypes.DATA_TYPE_FLOAT.equalsIgnoreCase(type)) {\r
 222                 convertedValue = Float.valueOf((String) value);\r
 223             }\r
 224         }\r
 225         logger.info("Returning value ({}) from convertPrimitiveResourceValue", convertedValue);\r
 226         return convertedValue;\r
 227     }\r
 228 \r
 229     @SuppressWarnings("squid:S1172")\r
 230     public static synchronized void setFailedResourceDataValue(Map<String, Object> componentContext,\r
 231             ResourceAssignment resourceAssignment, String message) {\r
 232         setFailedResourceDataValue(resourceAssignment, message);\r
 233     }\r
 234 \r
 235     public static synchronized void setFailedResourceDataValue(ResourceAssignment resourceAssignment, String message) {\r
 236         if (resourceAssignment != null && StringUtils.isNotBlank(resourceAssignment.getName())\r
 237                 && resourceAssignment.getProperty() != null) {\r
 238             resourceAssignment.setUpdatedDate(new Date());\r
 239             resourceAssignment.setStatus(ConfigModelConstant.STATUS_FAILURE);\r
 240             resourceAssignment.setUpdatedBy(ConfigModelConstant.USER_SYSTEM);\r
 241             resourceAssignment.setMessage(message);\r
 242         }\r
 243     }\r
 244 \r
 245     public static synchronized void assertTemplateKeyValueNotNull(Map<String, Object> componentContext,\r
 246             ResourceAssignment resourceAssignment) throws ConfigModelException {\r
 247         if (resourceAssignment != null && resourceAssignment.getProperty() != null\r
 248                 && BooleanUtils.isTrue(resourceAssignment.getProperty().getRequired())\r
 249                 && getTemplateKeyValue(componentContext, resourceAssignment) == null) {\r
 250             logger.error("failed to populate mandatory resource mapping ({})", resourceAssignment);\r
 251             throw new ConfigModelException(\r
 252                     String.format("failed to populate mandatory resource mapping (%s)", resourceAssignment));\r
 253         }\r
 254     }\r
 255 \r
 256     @SuppressWarnings({"squid:S3776", "squid:S1141"})\r
 257     public static synchronized String generateResourceDataForAssignments(List<ResourceAssignment> assignments)\r
 258             throws ConfigModelException {\r
 259         String result = "{}";\r
 260         try {\r
 261             ObjectMapper mapper = new ObjectMapper();\r
 262             JsonNode root = mapper.readTree(result);\r
 263             for (ResourceAssignment resourceMapping : assignments) {\r
 264                 if (resourceMapping != null && resourceMapping.getName() != null\r
 265                         && resourceMapping.getProperty() != null) {\r
 266 \r
 267                     String type = resourceMapping.getProperty().getType();\r
 268                     Object value = resourceMapping.getProperty().getValue();\r
 269                     logger.info("Generating Resource name ({}), type ({}), value ({})", resourceMapping.getName(), type,\r
 270                             value);\r
 271                     if (value == null) {\r
 272                         ((ObjectNode) root).set(resourceMapping.getName(), null);\r
 273                     } else if (value instanceof JsonNode) {\r
 274                         ((ObjectNode) root).put(resourceMapping.getName(), (JsonNode) value);\r
 275                     } else if (ValidTypes.DATA_TYPE_STRING.equalsIgnoreCase(type)) {\r
 276                         ((ObjectNode) root).put(resourceMapping.getName(), (String) value);\r
 277                     } else if (ValidTypes.DATA_TYPE_BOOLEAN.equalsIgnoreCase(type)) {\r
 278                         ((ObjectNode) root).put(resourceMapping.getName(), (Boolean) value);\r
 279                     } else if (ValidTypes.DATA_TYPE_INTEGER.equalsIgnoreCase(type)) {\r
 280                         ((ObjectNode) root).put(resourceMapping.getName(), (Integer) value);\r
 281                     } else if (ValidTypes.DATA_TYPE_FLOAT.equalsIgnoreCase(type)) {\r
 282                         ((ObjectNode) root).put(resourceMapping.getName(), (Float) value);\r
 283                     } else if (ValidTypes.DATA_TYPE_TIMESTAMP.equalsIgnoreCase(type)) {\r
 284                         ((ObjectNode) root).put(resourceMapping.getName(), (String) value);\r
 285                     } else {\r
 286                         JsonNode jsonNode = TransformationUtils.getJsonNodeForObject(value);\r
 287                         if (jsonNode != null) {\r
 288                             ((ObjectNode) root).put(resourceMapping.getName(), jsonNode);\r
 289                         } else {\r
 290                             ((ObjectNode) root).set(resourceMapping.getName(), null);\r
 291                         }\r
 292                     }\r
 293                 }\r
 294             }\r
 295             result = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(root);\r
 296             logger.info("Generated Resource Param Data ({})", result);\r
 297         } catch (Exception e) {\r
 298             throw new ConfigModelException(e.getMessage(), e);\r
 299         }\r
 300         return result;\r
 301     }\r
 302 \r
 303 }\r