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.BoundariesResource;
  19 import org.opendaylight.vtn.javaapi.resources.physical.BoundaryResource;
  20 import org.opendaylight.vtn.javaapi.validation.CommonValidator;
  21 import org.opendaylight.vtn.javaapi.validation.VtnServiceValidator;
  22
  23 /**
  24  * The Class BoundaryResourceValidator validates .
  25  */
  26 public class BoundaryResourceValidator extends VtnServiceValidator {
  27
  28         private static final Logger LOG = Logger
  29                         .getLogger(BoundaryResourceValidator.class.getName());
  30
  31         private final AbstractResource resource;
  32         final CommonValidator validator = new CommonValidator();
  33
  34         /**
  35          * Instantiates a new Boundary resource validator.
  36          *
  37          * @param resource
  38          *            the instance of AbstractResource
  39          */
  40         public BoundaryResourceValidator(final AbstractResource resource) {
  41                 this.resource = resource;
  42         }
  43
  44         /**
  45          * Validate uri parameters for Boundary API
  46          *
  47          * @return true, if successful
  48          */
  49         @Override
  50         public boolean validateUri() {
  51                 LOG.trace("Start BoundaryResourceValidator#validateUri()");
  52                 boolean isValid = false;
  53                 setInvalidParameter(VtnServiceJsonConsts.URI
  54                                 + VtnServiceJsonConsts.BOUNDARYID);
  55                 if (resource instanceof BoundaryResource
  56                                 && ((BoundaryResource) resource).getboundaryId() != null
  57                                 && !((BoundaryResource) resource).getboundaryId().trim()
  58                                                 .isEmpty()) {
  59                         isValid = validator.isValidMaxLengthAlphaNum(
  60                                         ((BoundaryResource) resource).getboundaryId().trim(),
  61                                         VtnServiceJsonConsts.LEN_31);
  62                         setListOpFlag(false);
  63                 } else if (resource instanceof BoundariesResource) {
  64                         isValid = true;
  65                         setListOpFlag(true);
  66                 }
  67                 LOG.trace("Complete BoundaryResourceValidator#validateUri()");
  68                 return isValid;
  69         }
  70
  71         /**
  72          * Validate request json for put, post and get methods of Boundary API
  73          */
  74         @Override
  75         public void validate(final String method, final JsonObject requestBody)
  76                         throws VtnServiceException {
  77                 LOG.trace("Start BoundaryResourceValidator#validate()");
  78                 LOG.info("Validating request for " + method
  79                                 + " of VtnResourceValidator");
  80                 boolean isValid = false;
  81                 try {
  82                         isValid = validateUri();
  83                         if (isValid && requestBody != null
  84                                         && VtnServiceConsts.GET.equals(method)) {
  85                                 isValid = isValidateGet(requestBody, isListOpFlag());
  86                                 updateOpParameterForList(requestBody);
  87                         } else if (isValid && requestBody != null
  88                                         && VtnServiceConsts.POST.equalsIgnoreCase(method)) {
  89                                 isValid = validatePost(requestBody);
  90                         } else if (isValid && requestBody != null
  91                                         && VtnServiceConsts.PUT.equals(method)) {
  92                                 isValid = validatePut(requestBody);
  93                         } else {
  94                                 isValid = false;
  95                         }
  96                 } catch (final NumberFormatException e) {
  97                         LOG.error("Inside catch:NumberFormatException");
  98                         isValid = false;
  99                 }
 100                 // Throws exception if validation fails
 101                 if (!isValid) {
 102                         LOG.error("Validation failed");
 103                         throw new VtnServiceException(Thread.currentThread()
 104                                         .getStackTrace()[1].getMethodName(),
 105                                         UncJavaAPIErrorCode.VALIDATION_ERROR.getErrorCode(),
 106                                         UncJavaAPIErrorCode.VALIDATION_ERROR.getErrorMessage());
 107                 }
 108                 LOG.info("Validation successful");
 109                 LOG.trace("Complete BoundaryResourceValidator#validate()");
 110         }
 111
 112         /**
 113          * Validate request json for get method of Boundary API
 114          *
 115          * @param requestBody
 116          *            the request Json object
 117          * @return true, if successful
 118          * @throws VtnServiceException
 119          */
 120         private boolean isValidateGet(final JsonObject requestBody,
 121                         final boolean opFlag) {
 122                 LOG.trace("Start BoundaryResourceValidator#isValidateGet()");
 123                 boolean isValid = true;
 124                 if (isValid) {
 125                         // validation for key: targetdb
 126                         setInvalidParameter(VtnServiceJsonConsts.TARGETDB);
 127                         isValid = validator.isValidRequestDB(requestBody);
 128                 }
 129                 if (!opFlag) {
 130                         if (requestBody.has(VtnServiceJsonConsts.OP)) {
 131                                 requestBody.remove(VtnServiceJsonConsts.OP);
 132                         } else {
 133                                 LOG.debug("No need to remove -op ");
 134                         }
 135                         if (requestBody.has(VtnServiceJsonConsts.INDEX)) {
 136                                 requestBody.remove(VtnServiceJsonConsts.INDEX);
 137                         } else {
 138                                 LOG.debug("No need to remove - index");
 139                         }
 140                         if (requestBody.has(VtnServiceJsonConsts.MAX)) {
 141                                 requestBody.remove(VtnServiceJsonConsts.MAX);
 142                         } else {
 143                                 LOG.debug("No need to remove-max count");
 144                         }
 145                 } else {
 146                         // validation for key: op
 147                         if (isValid) {
 148                                 setInvalidParameter(VtnServiceJsonConsts.OP);
 149                                 isValid = validator.isValidOperation(requestBody);
 150                         }
 151                         // validation for key: index
 152                         if (isValid) {
 153                                 setInvalidParameter(VtnServiceJsonConsts.INDEX);
 154                                 if (requestBody.has(VtnServiceJsonConsts.INDEX)
 155                                                 && requestBody.getAsJsonPrimitive(
 156                                                                 VtnServiceJsonConsts.INDEX).getAsString() != null
 157                                                 && !requestBody
 158                                                                 .getAsJsonPrimitive(VtnServiceJsonConsts.INDEX)
 159                                                                 .getAsString().trim().isEmpty()) {
 160                                         isValid = validator.isValidMaxLengthAlphaNum(requestBody
 161                                                         .getAsJsonPrimitive(VtnServiceJsonConsts.INDEX)
 162                                                         .getAsString().trim(), VtnServiceJsonConsts.LEN_31);
 163                                 }
 164                         }
 165                         // validation for key: max_repitition
 166                         if (isValid) {
 167                                 setInvalidParameter(VtnServiceJsonConsts.MAX);
 168                                 isValid = validator.isValidMaxRepetition(requestBody);
 169                         }
 170                         // validation for key: controller1_id
 171                         if (isValid) {
 172                                 setInvalidParameter(VtnServiceJsonConsts.CONTROLLER1ID);
 173                                 if (requestBody.has(VtnServiceJsonConsts.CONTROLLER1ID)
 174                                                 && requestBody.getAsJsonPrimitive(
 175                                                                 VtnServiceJsonConsts.CONTROLLER1ID)
 176                                                                 .getAsString() != null
 177                                                 && !requestBody
 178                                                                 .getAsJsonPrimitive(
 179                                                                                 VtnServiceJsonConsts.CONTROLLER1ID)
 180                                                                 .getAsString().trim().isEmpty()) {
 181                                         isValid = validator.isValidMaxLengthAlphaNum(
 182                                                         requestBody
 183                                                                         .getAsJsonPrimitive(
 184                                                                                         VtnServiceJsonConsts.CONTROLLER1ID)
 185                                                                         .getAsString().trim(),
 186                                                         VtnServiceJsonConsts.LEN_31);
 187                                 }
 188                         }
 189                         // validation for key: controller2_id
 190                         if (isValid) {
 191                                 setInvalidParameter(VtnServiceJsonConsts.CONTROLLER2ID);
 192                                 if (requestBody.has(VtnServiceJsonConsts.CONTROLLER2ID)
 193                                                 && requestBody.getAsJsonPrimitive(
 194                                                                 VtnServiceJsonConsts.CONTROLLER2ID)
 195                                                                 .getAsString() != null
 196                                                 && !requestBody
 197                                                                 .getAsJsonPrimitive(
 198                                                                                 VtnServiceJsonConsts.CONTROLLER2ID)
 199                                                                 .getAsString().trim().isEmpty()) {
 200                                         isValid = validator.isValidMaxLengthAlphaNum(
 201                                                         requestBody
 202                                                                         .getAsJsonPrimitive(
 203                                                                                         VtnServiceJsonConsts.CONTROLLER2ID)
 204                                                                         .getAsString().trim(),
 205                                                         VtnServiceJsonConsts.LEN_31);
 206                                 }
 207                         }
 208                 }
 209                 LOG.trace("Complete BoundaryResourceValidator#isValidateGet");
 210                 return isValid;
 211         }
 212
 213         /**
 214          * Validate post request json for create Boundary API
 215          *
 216          * @param requestBody
 217          *            the request Json object
 218          * @return true, if successful
 219          * @throws VtnServiceException
 220          */
 221         private boolean validatePost(final JsonObject requestBody)
 222                         throws VtnServiceException {
 223                 LOG.trace("Start BoundaryResourceValidator#validatePost()");
 224                 boolean isValid = false;
 225                 setInvalidParameter(VtnServiceJsonConsts.BOUNDARY);
 226                 if (requestBody.has(VtnServiceJsonConsts.BOUNDARY)
 227                                 && requestBody.get(VtnServiceJsonConsts.BOUNDARY)
 228                                                 .isJsonObject()) {
 229                         final JsonObject boundary = requestBody
 230                                         .getAsJsonObject(VtnServiceJsonConsts.BOUNDARY);
 231                         // validation for mandatory key: boundary_name(mandatory)
 232                         setInvalidParameter(VtnServiceJsonConsts.BOUNDARYID);
 233                         if (boundary.has(VtnServiceJsonConsts.BOUNDARYID)
 234                                         && boundary.getAsJsonPrimitive(
 235                                                         VtnServiceJsonConsts.BOUNDARYID).getAsString() != null) {
 236                                 isValid = validator.isValidMaxLengthAlphaNum(boundary
 237                                                 .getAsJsonPrimitive(VtnServiceJsonConsts.BOUNDARYID)
 238                                                 .getAsString().trim(), VtnServiceJsonConsts.LEN_31);
 239                         }
 240                         if (isValid) {
 241                                 // validation for key: description
 242                                 setInvalidParameter(VtnServiceJsonConsts.DESCRIPTION);
 243                                 if (boundary.has(VtnServiceJsonConsts.DESCRIPTION)
 244                                                 && boundary.getAsJsonPrimitive(
 245                                                                 VtnServiceJsonConsts.DESCRIPTION).getAsString() != null
 246                                                 && !boundary
 247                                                                 .getAsJsonPrimitive(
 248                                                                                 VtnServiceJsonConsts.DESCRIPTION)
 249                                                                 .getAsString().trim().isEmpty()) {
 250                                         isValid = validator.isValidMaxLength(
 251                                                         boundary.getAsJsonPrimitive(
 252                                                                         VtnServiceJsonConsts.DESCRIPTION)
 253                                                                         .getAsString().trim(),
 254                                                         VtnServiceJsonConsts.LEN_127);
 255                                 }
 256                         }
 257                         if (isValid) {
 258                                 setInvalidParameter(VtnServiceJsonConsts.LINK);
 259                                 if (isValid && boundary.has(VtnServiceJsonConsts.LINK)) {
 260                                         final JsonObject link = boundary
 261                                                         .getAsJsonObject(VtnServiceJsonConsts.LINK);
 262                                         // validation for key: controller1id (mandatory)
 263                                         setInvalidParameter(VtnServiceJsonConsts.CONTROLLER1ID);
 264                                         if (link.has(VtnServiceJsonConsts.CONTROLLER1ID)
 265                                                         && link.getAsJsonPrimitive(
 266                                                                         VtnServiceJsonConsts.CONTROLLER1ID)
 267                                                                         .getAsString() != null) {
 268                                                 isValid = validator.isValidMaxLengthAlphaNum(
 269                                                                 link.getAsJsonPrimitive(
 270                                                                                 VtnServiceJsonConsts.CONTROLLER1ID)
 271                                                                                 .getAsString().trim(),
 272                                                                 VtnServiceJsonConsts.LEN_31);
 273                                         } else {
 274                                                 isValid = false;
 275                                         }
 276                                         if (isValid) {
 277                                                 // validation for key: domain1_id (mandatory)
 278                                                 setInvalidParameter(VtnServiceJsonConsts.DOMAIN1_ID);
 279                                                 if (link.has(VtnServiceJsonConsts.DOMAIN1_ID)
 280                                                                 && link.getAsJsonPrimitive(
 281                                                                                 VtnServiceJsonConsts.DOMAIN1_ID)
 282                                                                                 .getAsString() != null) {
 283                                                         isValid = validator.isValidDomainId(
 284                                                                         link.getAsJsonPrimitive(
 285                                                                                         VtnServiceJsonConsts.DOMAIN1_ID)
 286                                                                                         .getAsString().trim(),
 287                                                                         VtnServiceJsonConsts.LEN_31);
 288                                                 } else {
 289                                                         isValid = false;
 290                                                 }
 291                                         }
 292                                         if (isValid) {
 293                                                 // validation for key: logical_port1_id (optional)
 294                                                 setInvalidParameter(VtnServiceJsonConsts.LOGICAL_PORT1_ID);
 295                                                 if (link.has(VtnServiceJsonConsts.LOGICAL_PORT1_ID)
 296                                                                 && link.getAsJsonPrimitive(
 297                                                                                 VtnServiceJsonConsts.LOGICAL_PORT1_ID)
 298                                                                                 .getAsString() != null
 299                                                                 && !link.getAsJsonPrimitive(
 300                                                                                 VtnServiceJsonConsts.LOGICAL_PORT1_ID)
 301                                                                                 .getAsString().trim().isEmpty()) {
 302                                                         isValid = validator
 303                                                                         .isValidMaxLength(
 304                                                                                         link.getAsJsonPrimitive(
 305                                                                                                         VtnServiceJsonConsts.LOGICAL_PORT1_ID)
 306                                                                                                         .getAsString().trim(),
 307                                                                                         VtnServiceJsonConsts.LEN_319);
 308                                                 }
 309                                         }
 310                                         if (isValid) {
 311                                                 // validation for key: controller2_id (mandatory)
 312                                                 setInvalidParameter(VtnServiceJsonConsts.CONTROLLER2ID);
 313                                                 if (link.has(VtnServiceJsonConsts.CONTROLLER2ID)
 314                                                                 && link.getAsJsonPrimitive(
 315                                                                                 VtnServiceJsonConsts.CONTROLLER2ID)
 316                                                                                 .getAsString() != null) {
 317                                                         isValid = validator.isValidMaxLengthAlphaNum(
 318                                                                         link.getAsJsonPrimitive(
 319                                                                                         VtnServiceJsonConsts.CONTROLLER2ID)
 320                                                                                         .getAsString().trim(),
 321                                                                         VtnServiceJsonConsts.LEN_31);
 322                                                 } else {
 323                                                         isValid = false;
 324                                                 }
 325                                         }
 326                                         if (isValid) {
 327                                                 // validation for key: domain2_id (mandatory)
 328                                                 setInvalidParameter(VtnServiceJsonConsts.DOMAIN2_ID);
 329                                                 if (link.has(VtnServiceJsonConsts.DOMAIN2_ID)
 330                                                                 && link.getAsJsonPrimitive(
 331                                                                                 VtnServiceJsonConsts.DOMAIN2_ID)
 332                                                                                 .getAsString() != null) {
 333                                                         isValid = validator.isValidDomainId(
 334                                                                         link.getAsJsonPrimitive(
 335                                                                                         VtnServiceJsonConsts.DOMAIN2_ID)
 336                                                                                         .getAsString().trim(),
 337                                                                         VtnServiceJsonConsts.LEN_31);
 338                                                 } else {
 339                                                         isValid = false;
 340                                                 }
 341                                         }
 342                                         if (isValid) {
 343                                                 // validation for key: logical_port2_id (optional)
 344                                                 setInvalidParameter(VtnServiceJsonConsts.LOGICAL_PORT2_ID);
 345                                                 if (link.has(VtnServiceJsonConsts.LOGICAL_PORT2_ID)
 346                                                                 && link.getAsJsonPrimitive(
 347                                                                                 VtnServiceJsonConsts.LOGICAL_PORT2_ID)
 348                                                                                 .getAsString() != null
 349                                                                 && !link.getAsJsonPrimitive(
 350                                                                                 VtnServiceJsonConsts.LOGICAL_PORT2_ID)
 351                                                                                 .getAsString().trim().isEmpty()) {
 352                                                         isValid = validator
 353                                                                         .isValidMaxLength(
 354                                                                                         link.getAsJsonPrimitive(
 355                                                                                                         VtnServiceJsonConsts.LOGICAL_PORT2_ID)
 356                                                                                                         .getAsString().trim(),
 357                                                                                         VtnServiceJsonConsts.LEN_319);
 358                                                 }
 359                                         }
 360                                 } else {
 361                                         isValid = false;
 362                                 }
 363                         }
 364                 } else {
 365                         isValid = false;
 366                 }
 367                 LOG.trace("Complete BoundaryResourceValidator#validatePost()");
 368                 return isValid;
 369         }
 370
 371         /**
 372          * Validate put request json for update Boundary API
 373          *
 374          * @param requestBody
 375          *            the request Json object
 376          *
 377          * @return true, if successful
 378          */
 379         private boolean validatePut(final JsonObject requestBody) {
 380                 LOG.trace("Start BoundaryResourceValidator#validatePut()");
 381                 boolean isValid = true;
 382                 setInvalidParameter(VtnServiceJsonConsts.BOUNDARY);
 383                 if (requestBody.has(VtnServiceJsonConsts.BOUNDARY)
 384                                 && requestBody.get(VtnServiceJsonConsts.BOUNDARY)
 385                                                 .isJsonObject()) {
 386                         final JsonObject boundary = requestBody
 387                                         .getAsJsonObject(VtnServiceJsonConsts.BOUNDARY);
 388                         // validation for key: description(optional)
 389                         setInvalidParameter(VtnServiceJsonConsts.DESCRIPTION);
 390                         if (boundary.has(VtnServiceJsonConsts.DESCRIPTION)
 391                                         && boundary.getAsJsonPrimitive(
 392                                                         VtnServiceJsonConsts.DESCRIPTION).getAsString() != null
 393                                         && !boundary
 394                                                         .getAsJsonPrimitive(
 395                                                                         VtnServiceJsonConsts.DESCRIPTION)
 396                                                         .getAsString().trim().isEmpty()) {
 397                                 isValid = validator.isValidMaxLength(boundary
 398                                                 .getAsJsonPrimitive(VtnServiceJsonConsts.DESCRIPTION)
 399                                                 .getAsString().trim(), VtnServiceJsonConsts.LEN_127);
 400                         }
 401                         if (isValid && boundary.has(VtnServiceJsonConsts.LINK)) {
 402                                 boundary.remove(VtnServiceJsonConsts.LINK);
 403                         }
 404                 } else {
 405                         isValid = false;
 406                 }
 407                 LOG.trace("Complete BoundaryResourceValidator#validatePut()");
 408                 return isValid;
 409         }
 410 }