git.opendaylight Code Review - vtn.git/blob

   1 /*
   2  * Copyright (c) 2012-2013 NEC Corporation
   3  * All rights reserved.
   4  *
   5  * This program and the accompanying materials are made available under the
   6  * terms of the Eclipse Public License v1.0 which accompanies this
   7  * distribution, and is available at http://www.eclipse.org/legal/epl-v10.html
   8  */
   9 package org.opendaylight.vtn.javaapi.validation.physical;
  10
  11 import com.google.gson.JsonObject;
  12 import org.opendaylight.vtn.core.util.Logger;
  13 import org.opendaylight.vtn.javaapi.constants.VtnServiceConsts;
  14 import org.opendaylight.vtn.javaapi.constants.VtnServiceJsonConsts;
  15 import org.opendaylight.vtn.javaapi.exception.VtnServiceException;
  16 import org.opendaylight.vtn.javaapi.ipc.enums.UncJavaAPIErrorCode;
  17 import org.opendaylight.vtn.javaapi.resources.AbstractResource;
  18 import org.opendaylight.vtn.javaapi.resources.physical.ControllerResource;
  19 import org.opendaylight.vtn.javaapi.resources.physical.ControllersResource;
  20 import org.opendaylight.vtn.javaapi.validation.CommonValidator;
  21 import org.opendaylight.vtn.javaapi.validation.VtnServiceValidator;
  22
  23 public class ControllerResourceValidator extends VtnServiceValidator {
  24
  25         private static final Logger LOG = Logger
  26                         .getLogger(ControllerResourceValidator.class.getName());
  27
  28         private final AbstractResource resource;
  29         final CommonValidator validator = new CommonValidator();
  30
  31         /**
  32          * Instantiates a new controller resource validator.
  33          *
  34          * @param resource
  35          *            the instance of AbstractResource
  36          */
  37         public ControllerResourceValidator(final AbstractResource resource) {
  38                 this.resource = resource;
  39         }
  40
  41         /**
  42          * Validate uri parameters for Controller API
  43          *
  44          * @return true, if successful
  45          */
  46         @Override
  47         public boolean validateUri() {
  48                 LOG.trace("Start ControllerResourceValidator#validateUri()");
  49                 boolean isValid = false;
  50                 setInvalidParameter(VtnServiceJsonConsts.CONTROLLERID);
  51                 if (resource instanceof ControllerResource
  52                                 && ((ControllerResource) resource).getControllerId() != null
  53                                 && !((ControllerResource) resource).getControllerId().trim()
  54                                                 .isEmpty()) {
  55                         isValid = validator.isValidMaxLengthAlphaNum(
  56                                         ((ControllerResource) resource).getControllerId().trim(),
  57                                         VtnServiceJsonConsts.LEN_31);
  58                         setListOpFlag(false);
  59                 } else if (resource instanceof ControllersResource) {
  60                         isValid = true;
  61                         setListOpFlag(true);
  62                 }
  63                 LOG.trace("Complete ControllerResourceValidator#validateUri()");
  64                 return isValid;
  65         }
  66
  67         /*
  68          * Validate request json for put, post and get method of controller API
  69          */
  70         @Override
  71         public void validate(final String method, final JsonObject requestBody)
  72                         throws VtnServiceException {
  73                 LOG.trace("Start ControlleResourceValidator#validate()");
  74                 LOG.info("Validating request for " + method
  75                                 + " of ControllerResourceValidator");
  76                 boolean isValid = false;
  77                 try {
  78                         isValid = validateUri();
  79                         if (isValid && requestBody != null
  80                                         && VtnServiceConsts.GET.equals(method)) {
  81                                 isValid = validateGet(requestBody, isListOpFlag());
  82                                 updateOpParameterForList(requestBody);
  83                         } else if (isValid && requestBody != null
  84                                         && VtnServiceConsts.POST.equalsIgnoreCase(method)) {
  85                                 isValid = validatePost(requestBody);
  86                         } else if (isValid && requestBody != null
  87                                         && VtnServiceConsts.PUT.equals(method)) {
  88                                 isValid = validatePut(requestBody);
  89                         } else {
  90                                 isValid = false;
  91                         }
  92                 } catch (final NumberFormatException e) {
  93                         LOG.error("Inside catch:NumberFormatException");
  94                         isValid = false;
  95                 }
  96                 // Throws exception if validation fails
  97                 if (!isValid) {
  98                         LOG.error("Validation failed");
  99                         throw new VtnServiceException(Thread.currentThread()
 100                                         .getStackTrace()[1].getMethodName(),
 101                                         UncJavaAPIErrorCode.VALIDATION_ERROR.getErrorCode(),
 102                                         UncJavaAPIErrorCode.VALIDATION_ERROR.getErrorMessage());
 103                 }
 104                 LOG.info("Validation successful");
 105                 LOG.trace("Complete ControllerResourceValidator#validate()");
 106         }
 107
 108         /**
 109          * Validate request json for get method of controller API
 110          *
 111          * @param requestBody
 112          *            the request Json object
 113          *
 114          * @return true, if is valid get
 115          */
 116         public boolean validateGet(final JsonObject requestBody,
 117                         final boolean opFlag) {
 118                 LOG.trace("Start ControllerResourceValidator#isValidGet");
 119                 boolean isValid = true;
 120                 // validation for key: targetdb
 121                 if (isValid) {
 122                         setInvalidParameter(VtnServiceJsonConsts.TARGETDB);
 123                         isValid = validator.isValidRequestDB(requestBody);
 124                 }
 125                 if (!opFlag) {
 126                         if (requestBody.has(VtnServiceJsonConsts.OP)) {
 127                                 requestBody.remove(VtnServiceJsonConsts.OP);
 128                         } else {
 129                                 LOG.debug("No need to remove");
 130                         }
 131                         if (requestBody.has(VtnServiceJsonConsts.INDEX)) {
 132                                 requestBody.remove(VtnServiceJsonConsts.INDEX);
 133                         } else {
 134                                 LOG.debug("No need to remove");
 135                         }
 136                         if (requestBody.has(VtnServiceJsonConsts.MAX)) {
 137                                 requestBody.remove(VtnServiceJsonConsts.MAX);
 138                         } else {
 139                                 LOG.debug("No need to remove");
 140                         }
 141                 } else {
 142                         // validation for key: op
 143                         if (isValid) {
 144                                 setInvalidParameter(VtnServiceJsonConsts.OP);
 145                                 isValid = validator.isValidOperation(requestBody);
 146                         }
 147                         // validation for key: index
 148                         if (isValid) {
 149                                 setInvalidParameter(VtnServiceJsonConsts.INDEX);
 150                                 if (requestBody.has(VtnServiceJsonConsts.INDEX)
 151                                                 && requestBody.getAsJsonPrimitive(
 152                                                                 VtnServiceJsonConsts.INDEX).getAsString() != null
 153                                                 && !requestBody
 154                                                                 .getAsJsonPrimitive(VtnServiceJsonConsts.INDEX)
 155                                                                 .getAsString().trim().isEmpty()) {
 156                                         isValid = validator.isValidMaxLengthAlphaNum(requestBody
 157                                                         .getAsJsonPrimitive(VtnServiceJsonConsts.INDEX)
 158                                                         .getAsString().trim(), VtnServiceJsonConsts.LEN_20);
 159                                 }
 160                         }
 161                         // validation for key: max_repitition
 162                         // updated validation for max_repetition_count
 163                         if (isValid) {
 164                                 setInvalidParameter(VtnServiceJsonConsts.MAX);
 165                                 isValid = validator.isValidMaxRepetition(requestBody);
 166                                 return isValid;
 167                         }
 168                 }
 169                 LOG.trace("Complete ControllerResourceValidator#isValidGet");
 170                 return isValid;
 171         }
 172
 173         /**
 174          * Validate request json for post method of controller API
 175          *
 176          * @param requestBody
 177          *            the request Json object
 178          *
 179          * @return true, if successful
 180          */
 181         private boolean validatePost(final JsonObject requestBody) {
 182                 LOG.trace("Start ControllerResourceValidator#validatePost()");
 183                 boolean isValid = false;
 184                 setInvalidParameter(VtnServiceJsonConsts.CONTROLLER);
 185                 if (requestBody.has(VtnServiceJsonConsts.CONTROLLER)
 186                                 && requestBody.get(VtnServiceJsonConsts.CONTROLLER)
 187                                                 .isJsonObject()) {
 188                         final JsonObject controller = requestBody
 189                                         .getAsJsonObject(VtnServiceJsonConsts.CONTROLLER);
 190                         // validation for mandatory key: controllerId(mandatory)
 191                         setInvalidParameter(VtnServiceJsonConsts.CONTROLLERID);
 192                         if (controller.has(VtnServiceJsonConsts.CONTROLLERID)
 193                                         && controller.getAsJsonPrimitive(
 194                                                         VtnServiceJsonConsts.CONTROLLERID).getAsString() != null) {
 195                                 isValid = validator.isValidMaxLengthAlphaNum(controller
 196                                                 .getAsJsonPrimitive(VtnServiceJsonConsts.CONTROLLERID)
 197                                                 .getAsString().trim(), VtnServiceJsonConsts.LEN_31);
 198                         }
 199                         if (isValid) {
 200                                 // validation for key: type(mandatory)
 201                                 setInvalidParameter(VtnServiceJsonConsts.TYPE);
 202                                 if (controller.has(VtnServiceJsonConsts.TYPE)
 203                                                 && controller.getAsJsonPrimitive(
 204                                                                 VtnServiceJsonConsts.TYPE).getAsString() != null) {
 205                                         isValid = validator.isValidType(controller
 206                                                         .getAsJsonPrimitive(VtnServiceJsonConsts.TYPE)
 207                                                         .getAsString().trim());
 208                                 } else {
 209                                         isValid = false;
 210                                 }
 211                         }
 212                         if (isValid) {
 213                                 // validation for key: version(mandatory)
 214                                 setInvalidParameter(VtnServiceJsonConsts.VERSION);
 215                                 if (controller.has(VtnServiceJsonConsts.VERSION)
 216                                                 && controller.getAsJsonPrimitive(
 217                                                                 VtnServiceJsonConsts.VERSION).getAsString() != null) {
 218                                         isValid = validator.isValidVersion(controller
 219                                                         .getAsJsonPrimitive(VtnServiceJsonConsts.VERSION)
 220                                                         .getAsString().trim(), VtnServiceJsonConsts.LEN_31);
 221                                 } else {
 222                                         isValid = false;
 223                                 }
 224                         }
 225                         if (isValid) {
 226                                 isValid = validateField(isValid, controller);
 227                         }
 228                 }
 229                 LOG.trace("Complete ControllerResourceValidator#validatePost()");
 230                 return isValid;
 231         }
 232
 233         /**
 234          * Validate common request for post and put method of controller API
 235          *
 236          * @param isValid
 237          *            boolean variable
 238          * @param controller
 239          *            the request Json object
 240          *
 241          * @return true, if successful
 242          */
 243         private boolean validateField(boolean isValid, final JsonObject controller) {
 244                 // validation for key: description
 245                 setInvalidParameter(VtnServiceJsonConsts.DESCRIPTION);
 246                 if (controller.has(VtnServiceJsonConsts.DESCRIPTION)
 247                                 && controller.getAsJsonPrimitive(
 248                                                 VtnServiceJsonConsts.DESCRIPTION).getAsString() != null
 249                                 && !controller
 250                                                 .getAsJsonPrimitive(VtnServiceJsonConsts.DESCRIPTION)
 251                                                 .getAsString().trim().isEmpty()) {
 252                         isValid = validator
 253                                         .isValidMaxLength(
 254                                                         controller
 255                                                                         .getAsJsonPrimitive(
 256                                                                                         VtnServiceJsonConsts.DESCRIPTION)
 257                                                                         .getAsString().trim(),
 258                                                         VtnServiceJsonConsts.LEN_127);
 259                 }
 260                 if (isValid) {
 261                         // validation for key: ipaddr
 262                         setInvalidParameter(VtnServiceJsonConsts.IPADDR);
 263                         if (controller.has(VtnServiceJsonConsts.IPADDR)
 264                                         && controller.getAsJsonPrimitive(
 265                                                         VtnServiceJsonConsts.IPADDR).getAsString() != null) {
 266                                 isValid = validator.isValidIpV4(controller
 267                                                 .getAsJsonPrimitive(VtnServiceJsonConsts.IPADDR)
 268                                                 .getAsString().trim());
 269                         }
 270                 }
 271                 if (isValid) {
 272                         // validation for key: audit_status
 273                         setInvalidParameter(VtnServiceJsonConsts.AUDITSTATUS);
 274                         if (controller.has(VtnServiceJsonConsts.AUDITSTATUS)
 275                                         && controller.getAsJsonPrimitive(
 276                                                         VtnServiceJsonConsts.AUDITSTATUS).getAsString() != null) {
 277                                 isValid = validator.isValidAuditStatus(controller
 278                                                 .getAsJsonPrimitive(VtnServiceJsonConsts.AUDITSTATUS)
 279                                                 .getAsString().trim());
 280                         }
 281                 }
 282                 if (isValid) {
 283                         // validation for key: username
 284                         setInvalidParameter(VtnServiceJsonConsts.USERNAME);
 285                         if (controller.has(VtnServiceJsonConsts.USERNAME)
 286                                         && controller.getAsJsonPrimitive(
 287                                                         VtnServiceJsonConsts.USERNAME).getAsString() != null) {
 288                                 isValid = validator.isValidMaxLength(controller
 289                                                 .getAsJsonPrimitive(VtnServiceJsonConsts.USERNAME)
 290                                                 .getAsString().trim(), VtnServiceJsonConsts.LEN_31);
 291                         }
 292                 }
 293                 if (isValid) {
 294                         // validation for key: password
 295                         setInvalidParameter(VtnServiceJsonConsts.PASSWORD);
 296                         if (controller.has(VtnServiceJsonConsts.PASSWORD)
 297                                         && controller.getAsJsonPrimitive(
 298                                                         VtnServiceJsonConsts.PASSWORD).getAsString() != null) {
 299                                 isValid = validator.isValidMaxLength(controller
 300                                                 .getAsJsonPrimitive(VtnServiceJsonConsts.PASSWORD)
 301                                                 .getAsString().trim(), VtnServiceJsonConsts.LEN_256);
 302                         }
 303                 }
 304                 return isValid;
 305         }
 306
 307         /**
 308          * Validate request json for put method of controller API
 309          *
 310          * @param requestBody
 311          *            the request Json object
 312          *
 313          * @return true, if successful
 314          */
 315         private boolean validatePut(final JsonObject requestBody) {
 316                 LOG.trace("Start ControllerResourceValidator#validatePut()");
 317                 boolean isValid = false;
 318                 setInvalidParameter(VtnServiceJsonConsts.CONTROLLER);
 319                 if (requestBody.has(VtnServiceJsonConsts.CONTROLLER)
 320                                 && requestBody.get(VtnServiceJsonConsts.CONTROLLER)
 321                                                 .isJsonObject()) {
 322                         isValid = true;
 323                         final JsonObject controller = requestBody
 324                                         .getAsJsonObject(VtnServiceJsonConsts.CONTROLLER);
 325                         /*
 326                          * // validation for key: type
 327                          * setInvalidParameter(VtnServiceJsonConsts.TYPE); if
 328                          * (controller.has(VtnServiceJsonConsts.TYPE) &&
 329                          * controller.getAsJsonPrimitive(
 330                          * VtnServiceJsonConsts.TYPE).getAsString() != null) { isValid =
 331                          * validator.isValidType(controller
 332                          * .getAsJsonPrimitive(VtnServiceJsonConsts.TYPE)
 333                          * .getAsString().trim()); }
 334                          */
 335
 336                         // Remove type if present in request JSON
 337                         if (controller.has(VtnServiceJsonConsts.TYPE)) {
 338                                 requestBody.getAsJsonObject(VtnServiceJsonConsts.CONTROLLER)
 339                                                 .remove(VtnServiceJsonConsts.TYPE);
 340                         }
 341                         // validation for key: version
 342                         setInvalidParameter(VtnServiceJsonConsts.VERSION);
 343                         if (controller.has(VtnServiceJsonConsts.VERSION)
 344                                         && controller.getAsJsonPrimitive(
 345                                                         VtnServiceJsonConsts.VERSION).getAsString() != null
 346                                         && !controller
 347                                                         .getAsJsonPrimitive(VtnServiceJsonConsts.VERSION)
 348                                                         .getAsString().trim().isEmpty()) {
 349                                 isValid = validator.isValidVersion(controller
 350                                                 .getAsJsonPrimitive(VtnServiceJsonConsts.VERSION)
 351                                                 .getAsString().trim(), VtnServiceJsonConsts.LEN_31);
 352                         }
 353                         if (isValid) {
 354                                 isValid = validateField(isValid, controller);
 355                         }
 356                 }
 357                 LOG.trace("Complete ControllerResourceValidator#validatePut()");
 358                 return isValid;
 359         }
 360 }