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