profiles/http/src/main/java/org/onap/cli/fw/http/schema/OnapCommandSchemaHttpLoader.java

   1 /*
   2  * Copyright 2017 Huawei Technologies Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.onap.cli.fw.http.schema;
  18
  19 import java.io.IOException;
  20 import java.util.ArrayList;
  21 import java.util.HashMap;
  22 import java.util.HashSet;
  23 import java.util.List;
  24 import java.util.Map;
  25 import java.util.Map.Entry;
  26 import java.util.Set;
  27 import java.util.stream.Collectors;
  28
  29 import org.onap.cli.fw.cmd.OnapCommand;
  30 import org.onap.cli.fw.cmd.OnapCommandType;
  31 import org.onap.cli.fw.conf.OnapCommandConfig;
  32 import org.onap.cli.fw.conf.OnapCommandConstants;
  33 import org.onap.cli.fw.error.OnapCommandException;
  34 import org.onap.cli.fw.error.OnapCommandInvalidSchema;
  35 import org.onap.cli.fw.error.OnapCommandNotFound;
  36 import org.onap.cli.fw.http.auth.OnapCommandHttpService;
  37 import org.onap.cli.fw.http.cmd.OnapHttpCommand;
  38 import org.onap.cli.fw.http.conf.OnapCommandHttpConstants;
  39 import org.onap.cli.fw.http.error.OnapCommandHttpInvalidResultMap;
  40 import org.onap.cli.fw.registrar.OnapCommandRegistrar;
  41 import org.onap.cli.fw.schema.OnapCommandSchemaLoader;
  42 import org.onap.cli.fw.utils.OnapCommandUtils;
  43
  44 import com.fasterxml.jackson.databind.ObjectMapper;
  45
  46 import net.minidev.json.JSONObject;
  47
  48 public class OnapCommandSchemaHttpLoader {
  49
  50     public static List<String> loadHttpSchema(OnapHttpCommand cmd, String schemaName, boolean includeDefault,
  51                                           boolean validateSchema) throws OnapCommandException {
  52         try {
  53             List<String> errors = new ArrayList<>();
  54             if (includeDefault) {
  55                 Map<String, ?> defaultParameterMap = OnapCommandSchemaLoader.validateSchemaVersion(OnapCommandHttpConstants.DEFAULT_PARAMETER_HTTP_FILE_NAME, cmd.getSchemaVersion());
  56
  57                 //mrkanag default_parameter is supported only for parameters.
  58                 if (defaultParameterMap.containsKey(OnapCommandConstants.INFO)) {
  59                     defaultParameterMap.remove(OnapCommandConstants.INFO);
  60                 }
  61
  62                 errors.addAll(OnapCommandSchemaLoader.parseSchema(cmd, defaultParameterMap, validateSchema));
  63             }
  64
  65             Map<String, List<Map<String, String>>> commandYamlMap =
  66                     (Map<String, List<Map<String, String>>>)OnapCommandSchemaLoader.validateSchemaVersion(schemaName, cmd.getSchemaVersion());
  67
  68             errors.addAll(parseHttpSchema(cmd, commandYamlMap, validateSchema));
  69
  70             return errors;
  71
  72         } catch (OnapCommandException e) {
  73             throw e;
  74         } catch (Exception e) {
  75             throw new OnapCommandInvalidSchema(schemaName, e);
  76         }
  77     }
  78
  79     /**
  80      * Load the schema.
  81      *
  82      * @param cmd
  83      *            OnapHttpCommand
  84      * @param schemaName
  85      *            schema name
  86      * @throws OnapCommandException
  87      *             on error
  88      */
  89     public static ArrayList<String> parseHttpSchema(OnapHttpCommand cmd,
  90                                                     final Map<String, ?> values,
  91                                                     boolean validate) throws OnapCommandException {
  92         ArrayList<String> errorList = new ArrayList<>();
  93         try {
  94             Map<String, ?> valMap = (Map<String, ?>) values.get(OnapCommandHttpConstants.HTTP);
  95
  96             if (valMap != null) {
  97                 if (validate) {
  98                     OnapCommandUtils.validateTags(errorList, valMap, OnapCommandConfig.getCommaSeparatedList(OnapCommandHttpConstants.HTTP_SECTIONS),
  99                             OnapCommandConfig.getCommaSeparatedList(OnapCommandHttpConstants.HTTP_MANDATORY_SECTIONS), OnapCommandHttpConstants.HTTP);
 100                     errorList.addAll(validateHttpSchemaSection(values));
 101                 }
 102                 for (Map.Entry<String, ?> entry1 : valMap.entrySet()) {
 103                     String key1 = entry1.getKey();
 104
 105                     switch (key1) {
 106                         case OnapCommandHttpConstants.REQUEST:
 107                             Map<String, ?> map = (Map<String, ?>) valMap.get(key1);
 108
 109                             for (Map.Entry<String, ?> entry2 : map.entrySet()) {
 110                                 try {
 111                                     String key2 = entry2.getKey();
 112
 113                                     switch (key2) {
 114                                         case OnapCommandHttpConstants.URI:
 115                                             Object obj = map.get(key2);
 116                                             cmd.getInput().setUri(obj.toString());
 117                                             break;
 118                                         case OnapCommandHttpConstants.METHOD_TYPE:
 119                                             Object method = map.get(key2);
 120                                             cmd.getInput().setMethod(method.toString());
 121                                             break;
 122                                         case OnapCommandHttpConstants.BODY:
 123                                             Object body = map.get(key2);
 124                                             cmd.getInput().setBody(body.toString());
 125                                             break;
 126                                         case OnapCommandHttpConstants.HEADERS:
 127                                             Map<String, String> head = (Map<String, String>) map.get(key2);
 128                                             cmd.getInput().setReqHeaders(head);
 129                                             break;
 130                                         case OnapCommandHttpConstants.QUERIES:
 131                                             Map<String, String> query = (Map<String, String>) map.get(key2);
 132
 133                                             cmd.getInput().setReqQueries(query);
 134                                             break;
 135                                         case OnapCommandHttpConstants.MULTIPART_ENTITY_NAME:
 136                                             Object multipartEntityName = map.get(key2);
 137                                             cmd.getInput().setMultipartEntityName(multipartEntityName.toString());
 138                                             break;
 139                                     }
 140                                 }catch (Exception ex) {
 141                                     OnapCommandUtils.throwOrCollect(new OnapCommandInvalidSchema(cmd.getSchemaName(), ex), errorList, validate);
 142                                 }
 143                             }
 144                             break;
 145
 146                         case OnapCommandHttpConstants.SERVICE:
 147                             Map<String, String> serviceMap = (Map<String, String>) valMap.get(key1);
 148
 149                             if (serviceMap != null) {
 150                                 if (validate) {
 151                                     OnapCommandUtils.validateTags(errorList, (Map<String, Object>) valMap.get(key1),
 152                                             OnapCommandConfig.getCommaSeparatedList(OnapCommandHttpConstants.SERVICE_PARAMS_LIST),
 153                                             OnapCommandConfig.getCommaSeparatedList(OnapCommandHttpConstants.SERVICE_PARAMS_MANDATORY_LIST), OnapCommandHttpConstants.SERVICE);
 154
 155                                     HashMap<String, String> validationMap = new HashMap<>();
 156                                     validationMap.put(OnapCommandHttpConstants.AUTH, OnapCommandHttpConstants.AUTH_VALUES);
 157                                     validationMap.put(OnapCommandHttpConstants.MODE, OnapCommandHttpConstants.MODE_VALUES);
 158
 159                                     for (String secKey : validationMap.keySet()) {
 160                                         if (serviceMap.containsKey(secKey)) {
 161                                             Object obj = serviceMap.get(secKey);
 162                                             if (obj == null) {
 163                                                 errorList.add("Attribute '" + secKey + "' under '" + OnapCommandHttpConstants.SERVICE + "' is empty");
 164                                             } else {
 165                                                 String value = String.valueOf(obj);
 166                                                 if (!OnapCommandConfig.getCommaSeparatedList(validationMap.get(secKey)).contains(value)) {
 167                                                     errorList.add("Attribute '" + secKey + "' contains invalid value. Valide values are "
 168                                                             + OnapCommandConfig.getCommaSeparatedList(validationMap.get(key1))); //
 169                                                 }
 170                                             }
 171                                         }
 172                                     }
 173                                 }
 174
 175                                 OnapCommandHttpService srv = new OnapCommandHttpService();
 176
 177                                 for (Map.Entry<String, String> entry : serviceMap.entrySet()) {
 178                                     String key = entry.getKey();
 179
 180                                     switch (key) {
 181                                         case OnapCommandConstants.NAME:
 182                                             srv.setName(serviceMap.get(key));
 183                                             break;
 184
 185                                         case OnapCommandHttpConstants.VERSION:
 186                                             srv.setVersion(serviceMap.get(key).toString());
 187                                             break;
 188
 189                                         case OnapCommandHttpConstants.AUTH:
 190                                             Object obj = serviceMap.get(key);
 191                                             srv.setAuthType(obj.toString());
 192                                             break;
 193
 194                                         case OnapCommandHttpConstants.MODE:
 195                                             Object mode = serviceMap.get(key);
 196                                             srv.setMode(mode.toString());
 197                                             break;
 198                                     }
 199                                 }
 200
 201                                 cmd.setService(srv);
 202                             }
 203                             break;
 204
 205                         case OnapCommandHttpConstants.SUCCESS_CODES:
 206                             if (validate) {
 207                                 validateHttpSccessCodes(errorList, (List<Object>) valMap.get(key1));
 208                             }
 209                             cmd.setSuccessStatusCodes((ArrayList) valMap.get(key1));
 210                             break;
 211
 212                         case OnapCommandHttpConstants.RESULT_MAP:
 213                             if (validate) {
 214                                 validateHttpResultMap(errorList, values);
 215                             }
 216                             cmd.setResultMap((Map<String, String>) valMap.get(key1));
 217                             break;
 218
 219                         case OnapCommandHttpConstants.SAMPLE_RESPONSE:
 220                             // (mrkanag) implement sample response handling
 221                             break;
 222                     }
 223                 }
 224             }
 225         }catch (OnapCommandException e) {
 226             OnapCommandUtils.throwOrCollect(e, errorList, validate);
 227         }
 228
 229         //Handle the parameters for auth:
 230         // for commands, copy params from login command to this command
 231         if (!cmd.getService().isNoAuth()) {
 232             if (cmd.getInfo().getCommandType().equals(OnapCommandType.AUTH)) {
 233                 OnapCommandUtils.throwOrCollect(new OnapCommandInvalidSchema(
 234                         cmd.getSchemaName(), "For auth type commands, http->service->auth should be none"),
 235                         errorList,
 236                         validate);
 237             } else {
 238                 OnapCommand login = OnapCommandSchemaHttpLoader.findAuthCommand(cmd, "login");
 239                 OnapCommandUtils.copyParamSchemasFrom(login, cmd);
 240             }
 241         } else {
 242             //with service->auth: none,
 243             //normal cmd: ignore all auth parms
 244             if (!cmd.getInfo().getCommandType().equals(OnapCommandType.AUTH)) {
 245                 cmd.getParametersMap().get(OnapCommandHttpConstants.DEAFULT_PARAMETER_USERNAME).setInclude(false);
 246                 cmd.getParametersMap().get(OnapCommandHttpConstants.DEAFULT_PARAMETER_PASSWORD).setInclude(false);
 247                 cmd.getParametersMap().get(OnapCommandHttpConstants.DEFAULT_PARAMETER_NO_AUTH).setInclude(false);
 248             } else {
 249                 //auth: login and logout commands, ignore no-auth
 250                 cmd.getParametersMap().get(OnapCommandHttpConstants.DEFAULT_PARAMETER_NO_AUTH).setInclude(false);
 251                 //auth: only for logout commands, ignore username and password too
 252                 if (!cmd.getName().endsWith(OnapCommandHttpConstants.AUTH_SERVICE_LOGIN)) {
 253                     cmd.getParametersMap().get(OnapCommandHttpConstants.DEAFULT_PARAMETER_USERNAME).setInclude(false);
 254                     cmd.getParametersMap().get(OnapCommandHttpConstants.DEAFULT_PARAMETER_PASSWORD).setInclude(false);
 255                 }
 256             }
 257         }
 258
 259         return errorList;
 260     }
 261
 262     public static ArrayList<String> validateHttpSchemaSection(Map<String, ?> values) {
 263         ArrayList<String> errorList = new ArrayList<>();
 264         Map<String, ?> map = (Map<String, ?>) values.get(OnapCommandHttpConstants.HTTP);
 265         Map<String, Object> requestMap = (Map<String, Object>) map.get(OnapCommandHttpConstants.REQUEST);
 266
 267         if (requestMap != null && !requestMap.isEmpty()) {
 268             OnapCommandUtils.validateTags(errorList, requestMap, OnapCommandConfig.getCommaSeparatedList(OnapCommandHttpConstants.HTTP_REQUEST_PARAMS),
 269                     OnapCommandConfig.getCommaSeparatedList(OnapCommandHttpConstants.HTTP_REQUEST_MANDATORY_PARAMS), OnapCommandHttpConstants.REQUEST);
 270             String method = (String) requestMap.get(OnapCommandHttpConstants.METHOD);
 271             if (method != null && !method.isEmpty()) {
 272                 if (!OnapCommandConfig.getCommaSeparatedList(OnapCommandHttpConstants.HTTP_METHODS).contains(method.toLowerCase())) {
 273                     errorList.add("Attribute '" + OnapCommandHttpConstants.METHOD + "' under '" + OnapCommandHttpConstants.REQUEST + "' is invalid, correct types are "
 274                             + OnapCommandConfig.getCommaSeparatedList(OnapCommandHttpConstants.HTTP_METHODS).toString());
 275                 }
 276             } else {
 277                 errorList.add("Http request method cann't be null or empty");
 278             }
 279
 280             Set<String> requestParams = getRequestParams(values);
 281
 282             Set<String> uriParams = validateHttpUri(errorList, requestMap);
 283
 284             Set<String> bodyParams = validateHttpBody(errorList, requestMap);
 285
 286             Set<String> headerParams = validateHttpHeaders(requestMap);
 287
 288             Set<String> queryParams = validateHttpQueries(requestMap);
 289
 290             HashSet<String> totoalParams = new HashSet<>(uriParams);
 291             totoalParams.addAll(bodyParams);
 292             totoalParams.addAll(headerParams);
 293             totoalParams.addAll(queryParams);
 294
 295             List<String> nonDeclaredParams = totoalParams.stream().filter(param -> !requestParams.contains(param))
 296                     .collect(Collectors.toList());
 297
 298             nonDeclaredParams.stream().forEach(p -> errorList.add("The parameter '" + p
 299                     + "' declared under 'parameters:' section is not mapped into request section."));
 300         } else {
 301             errorList.add(OnapCommandUtils.emptySection(OnapCommandHttpConstants.REQUEST));
 302         }
 303         return errorList;
 304     }
 305
 306     public static void validateHttpSccessCodes(List<String> errorList, List<Object> requestSuccessCodes) {
 307
 308         if (requestSuccessCodes == null || requestSuccessCodes.isEmpty()) {
 309             errorList.add(OnapCommandHttpConstants.HTTP_SUCCESS_CODE_INVALID);
 310             return;
 311         }
 312
 313         for (Object successCode : requestSuccessCodes) {
 314             Integer code = (Integer) successCode;
 315             if (code < 200 || code >= 300) {
 316                 if ( code != 404) {
 317                     errorList.add(OnapCommandHttpConstants.HTTP_SUCCESS_CODE_INVALID);
 318                 }
 319             }
 320         }
 321
 322     }
 323
 324     public static void validateHttpResultMap(List<String> errorList, Map<String, ?> values) throws OnapCommandException {
 325         Map<String, ?> valMap = (Map<String, ?>) values.get(OnapCommandHttpConstants.HTTP);
 326         List<Map<String, String>> attributes = (List<Map<String, String>>) ((Map<String, ?>)values.get(OnapCommandConstants.RESULTS)).get(OnapCommandConstants.ATTRIBUTES);
 327         Set<String> resultMapParams = ((Map<String, String>) valMap.get(OnapCommandHttpConstants.RESULT_MAP)).keySet();
 328
 329         Set<String> resultAttNames = attributes.stream().map(map -> map.get(OnapCommandConstants.NAME))
 330                 .collect(Collectors.toSet());
 331
 332         List<String> invaliResultMapParams = resultMapParams.stream()
 333                 .filter(p -> !resultAttNames.contains(p)).collect(Collectors.toList());
 334         List<String> attributesMissing = resultAttNames.stream()
 335                 .filter(p -> !resultMapParams.contains(p)).collect(Collectors.toList());
 336         invaliResultMapParams.addAll(attributesMissing);
 337
 338         if (!invaliResultMapParams.isEmpty()) {
 339             OnapCommandUtils.throwOrCollect(new OnapCommandHttpInvalidResultMap(invaliResultMapParams), errorList, true);
 340         }
 341     }
 342
 343     public static Set<String> validateHttpQueries(Map<String, Object> requestMap) {
 344         Map<String, Object> queries = (Map<String, Object>) requestMap.get(OnapCommandHttpConstants.QUERIES);
 345         Set<String> queryParamNames = new HashSet<>();
 346         if (queries != null) {
 347             for (Entry<String, Object> entry : queries.entrySet()) {
 348                 OnapCommandUtils.parseParameters(String.valueOf(entry.getValue()), queryParamNames);
 349             }
 350         }
 351         return queryParamNames;
 352     }
 353
 354     public static Set<String> validateHttpHeaders(Map<String, Object> requestMap) {
 355
 356         Map<String, Object> headers = (Map<String, Object>) requestMap.get(OnapCommandHttpConstants.HEADERS);
 357         Set<String> headerParamNames = new HashSet<>();
 358         if (headers != null) {
 359             for (Entry<String, Object> entry : headers.entrySet()) {
 360                 OnapCommandUtils.parseParameters(String.valueOf(entry.getValue()), headerParamNames);
 361             }
 362         }
 363         return headerParamNames;
 364     }
 365
 366     public static Set<String> validateHttpBody(List<String> errorList, Map<String, Object> requestMap) {
 367         Set<String> bodyParamNames = new HashSet<>();
 368         Object bodyString = requestMap.get(OnapCommandHttpConstants.BODY);
 369         if (bodyString == null) {
 370             return bodyParamNames;
 371         }
 372
 373         String body = String.valueOf(bodyString);
 374         JSONObject obj = null;
 375         try {
 376             obj = new ObjectMapper().readValue(body, JSONObject.class);
 377         } catch (IOException e1) { // NOSONAR
 378             errorList.add(OnapCommandHttpConstants.HTTP_BODY_FAILED_PARSING);
 379         }
 380         if (obj == null || "".equals(obj.toString())) {
 381             errorList.add(OnapCommandHttpConstants.HTTP_BODY_JSON_EMPTY);
 382         }
 383         OnapCommandUtils.parseParameters(body, bodyParamNames);
 384
 385         return bodyParamNames;
 386     }
 387
 388     public static Set<String> validateHttpUri(List<String> errorList, Map<String, Object> requestMap) {
 389         Set<String> uriParamNames = new HashSet<>();
 390         String uri = (String) requestMap.get(OnapCommandHttpConstants.URI);
 391         if (uri == null || uri.isEmpty()) {
 392             errorList.add(OnapCommandUtils.emptySection(OnapCommandHttpConstants.URI));
 393             return uriParamNames;
 394         }
 395         OnapCommandUtils.parseParameters(uri, uriParamNames);
 396         return uriParamNames;
 397     }
 398
 399     public static Set<String> getRequestParams(Map<String, ?> yamlMap) {
 400
 401         Set<String> set = new HashSet<>();
 402
 403         @SuppressWarnings("unchecked")
 404         List<Map<String, Object>> inputParams = (List<Map<String, Object>>) yamlMap.get(OnapCommandConstants.PARAMETERS);
 405
 406         if (inputParams != null) {
 407             for (Map<String, Object> map : inputParams) {
 408                 for (Entry<String, Object> entry : map.entrySet()) {
 409                     Object key = entry.getKey();
 410
 411                     if (OnapCommandConstants.NAME.equals(key)) {
 412                         set.add(String.valueOf(entry.getValue()));
 413                         break;
 414                     }
 415                 }
 416             }
 417         }
 418
 419         return set;
 420     }
 421
 422     /**
 423         *
 424         * @param authAction login/logout
 425         * @return
 426         * @throws OnapCommandException
 427         */
 428        public static OnapCommand findAuthCommand(OnapHttpCommand forCmd, String authAction) throws OnapCommandException {
 429            OnapCommand auth = null;
 430            try {
 431                //mrkanag: fix this to discover the auth command by matching info->product & service
 432                auth = OnapCommandRegistrar.getRegistrar().get(
 433                        forCmd.getInfo().getService() + "-" +
 434                        forCmd.getService().getAuthType() + "-" + authAction,
 435                        forCmd.getInfo().getProduct());
 436            } catch (OnapCommandNotFound e) {  // NOSONAR
 437                auth = OnapCommandRegistrar.getRegistrar().get(
 438                        forCmd.getService().getAuthType() + "-" + authAction,
 439                        forCmd.getInfo().getProduct());
 440            }
 441
 442            return auth;
 443        }
 444
 445
 446 }