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.logical;
  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.logical.VTunnelResource;
  19 import org.opendaylight.vtn.javaapi.resources.logical.VTunnelsResource;
  20 import org.opendaylight.vtn.javaapi.validation.CommonValidator;
  21 import org.opendaylight.vtn.javaapi.validation.VtnServiceValidator;
  22
  23 /**
  24  * The Class VTunnelResourceValidator validates request Json object for Vtunnel
  25  * API.
  26  */
  27 public class VTunnelResourceValidator extends VtnServiceValidator {
  28
  29         private static final Logger LOG = Logger
  30                         .getLogger(VTunnelResourceValidator.class.getName());
  31
  32         private final AbstractResource resource;
  33         final CommonValidator validator = new CommonValidator();
  34
  35         /**
  36          * Instantiates a new v tunnel resource validator.
  37          *
  38          * @param resource
  39          *            the instance of AbstractResource
  40          */
  41         public VTunnelResourceValidator(final AbstractResource resource) {
  42                 this.resource = resource;
  43         }
  44
  45         /**
  46          * Validate uri parameters for VTunnel API.
  47          *
  48          * @return true, if successful
  49          */
  50         @Override
  51         public boolean validateUri() {
  52                 LOG.trace("Start VTunnelResourceValidator#validateUri()");
  53                 boolean isValid = false;
  54                 setInvalidParameter(VtnServiceJsonConsts.URI
  55                                 + VtnServiceJsonConsts.VTNNAME);
  56                 if (resource instanceof VTunnelsResource
  57                                 && ((VTunnelsResource) resource).getVtnName() != null
  58                                 && !((VTunnelsResource) resource).getVtnName().trim().isEmpty()) {
  59                         isValid = validator.isValidMaxLengthAlphaNum(
  60                                         ((VTunnelsResource) resource).getVtnName().trim(),
  61                                         VtnServiceJsonConsts.LEN_31);
  62                         setListOpFlag(true);
  63                 } else if (resource instanceof VTunnelResource
  64                                 && ((VTunnelResource) resource).getVtnName() != null
  65                                 && !((VTunnelResource) resource).getVtnName().trim().isEmpty()) {
  66                         isValid = validator.isValidMaxLengthAlphaNum(
  67                                         ((VTunnelResource) resource).getVtnName().trim(),
  68                                         VtnServiceJsonConsts.LEN_31);
  69                         if (isValid) {
  70                                 setInvalidParameter(VtnServiceJsonConsts.URI
  71                                                 + VtnServiceJsonConsts.VTUNNELNAME);
  72                                 if (((VTunnelResource) resource).getvTunnelName() != null
  73                                                 && !((VTunnelResource) resource).getvTunnelName()
  74                                                                 .trim().isEmpty()) {
  75                                         isValid = validator.isValidMaxLengthAlphaNum(
  76                                                         ((VTunnelResource) resource).getvTunnelName()
  77                                                                         .trim(), VtnServiceJsonConsts.LEN_31);
  78                                 } else {
  79                                         isValid = false;
  80                                 }
  81                         }
  82                         setListOpFlag(false);
  83                 }
  84                 LOG.trace("Complete VTunnelResourceValidator#validateUri()");
  85                 return isValid;
  86         }
  87
  88         /**
  89          * Validate request Json object for get, put and post method of VTunnel API.
  90          */
  91         @Override
  92         public void validate(final String method, final JsonObject requestBody)
  93                         throws VtnServiceException {
  94                 LOG.trace("Start VTunnelResource#validate()");
  95                 LOG.info("Validating request for " + method
  96                                 + " of VTunnelResourceValidator");
  97                 boolean isValid = false;
  98                 try {
  99                         isValid = validateUri();
 100                         if (isValid && requestBody != null
 101                                         && VtnServiceConsts.GET.equals(method)) {
 102                                 isValid = validator.isValidGet(requestBody, isListOpFlag());
 103                                 setInvalidParameter(validator.getInvalidParameter());
 104                                 updateOpParameterForList(requestBody);
 105                         } else if (isValid && requestBody != null
 106                                         && VtnServiceConsts.POST.equals(method)) {
 107                                 isValid = validatePost(requestBody);
 108                         } else if (isValid && requestBody != null
 109                                         && VtnServiceConsts.PUT.equals(method)) {
 110                                 isValid = validatePut(requestBody);
 111                         } else if (isValid) {
 112                                 setInvalidParameter(VtnServiceConsts.INCORRECT_METHOD_INVOCATION);
 113                                 isValid = false;
 114                         }
 115                 } catch (final NumberFormatException e) {
 116                         LOG.error("Inside catch:NumberFormatException");
 117                         if (method.equals(VtnServiceConsts.GET)) {
 118                                 setInvalidParameter(validator.getInvalidParameter());
 119                         }
 120                         isValid = false;
 121                 } catch (final ClassCastException e) {
 122                         if (method.equals(VtnServiceConsts.GET)) {
 123                                 setInvalidParameter(validator.getInvalidParameter());
 124                         }
 125                         LOG.error("Inside catch:ClassCastException");
 126                         isValid = false;
 127                 }
 128                 // Throws exception if validation fails
 129                 if (!isValid) {
 130                         LOG.error("Validation failed");
 131                         throw new VtnServiceException(Thread.currentThread()
 132                                         .getStackTrace()[1].getMethodName(),
 133                                         UncJavaAPIErrorCode.VALIDATION_ERROR.getErrorCode(),
 134                                         UncJavaAPIErrorCode.VALIDATION_ERROR.getErrorMessage());
 135                 }
 136                 LOG.info("Validation successful");
 137                 LOG.trace("Complete VTunnelResourceValidator#validate()");
 138         }
 139
 140         /**
 141          * Validate post request Json object for VTunnel API
 142          *
 143          * @param requestBody
 144          *            the request Json object
 145          * @return true, if successful
 146          * @throws VtnServiceException
 147          *             the vtn service exception
 148          */
 149         private boolean validatePost(final JsonObject requestBody)
 150                         throws VtnServiceException {
 151                 LOG.trace("Start VTunnelResourceValidator#validatePost()");
 152                 boolean isValid = false;
 153                 setInvalidParameter(VtnServiceJsonConsts.VTUNNEL);
 154                 if (requestBody.has(VtnServiceJsonConsts.VTUNNEL)
 155                                 && requestBody.get(VtnServiceJsonConsts.VTUNNEL).isJsonObject()) {
 156                         final JsonObject vTunnel = requestBody
 157                                         .getAsJsonObject(VtnServiceJsonConsts.VTUNNEL);
 158                         // validation for key: vtunnel_name(mandatory)
 159                         setInvalidParameter(VtnServiceJsonConsts.VTUNNELNAME);
 160                         if (vTunnel.has(VtnServiceJsonConsts.VTUNNELNAME)
 161                                         && vTunnel.getAsJsonPrimitive(
 162                                                         VtnServiceJsonConsts.VTUNNELNAME).getAsString() != null) {
 163                                 isValid = validator.isValidMaxLengthAlphaNum(vTunnel
 164                                                 .getAsJsonPrimitive(VtnServiceJsonConsts.VTUNNELNAME)
 165                                                 .getAsString().trim(), VtnServiceJsonConsts.LEN_31);
 166                         }
 167                         // validation for key: controller_id(mandatory)
 168                         if (isValid) {
 169                                 setInvalidParameter(VtnServiceJsonConsts.CONTROLLERID);
 170                                 if (vTunnel.has(VtnServiceJsonConsts.CONTROLLERID)
 171                                                 && vTunnel.getAsJsonPrimitive(
 172                                                                 VtnServiceJsonConsts.CONTROLLERID)
 173                                                                 .getAsString() != null) {
 174                                         isValid = validator.isValidMaxLengthAlphaNum(
 175                                                         vTunnel.getAsJsonPrimitive(
 176                                                                         VtnServiceJsonConsts.CONTROLLERID)
 177                                                                         .getAsString().trim(),
 178                                                         VtnServiceJsonConsts.LEN_31);
 179                                 } else {
 180                                         isValid = false;
 181                                 }
 182                         }
 183                         if (isValid) {
 184                                 // validation for key: description(optional),  vtn_name(optional), vtepgroup_name(optional), label(optional)
 185                                 isValid = commonValidations(isValid, vTunnel);
 186                         }
 187                         // validation for key: DomainId(optional)
 188                         if (isValid) {
 189                                 setInvalidParameter(VtnServiceJsonConsts.DOMAINID);
 190                                 if (vTunnel.has(VtnServiceJsonConsts.DOMAINID)
 191                                                 && vTunnel.getAsJsonPrimitive(
 192                                                                 VtnServiceJsonConsts.DOMAINID).getAsString() != null) {
 193                                         isValid = validator.isValidDomainId(vTunnel
 194                                                         .getAsJsonPrimitive(VtnServiceJsonConsts.DOMAINID)
 195                                                         .getAsString().trim(), VtnServiceJsonConsts.LEN_31);
 196                                 } else {
 197                                         isValid = false;
 198                                 }
 199                         }
 200                 }
 201                 LOG.trace("complete VTunnelResourceValidator#validatePost()");
 202                 return isValid;
 203         }
 204
 205         /**
 206          * @param isValid
 207          * @param vTunnel
 208          * @return
 209          */
 210         private boolean commonValidations(boolean isValid, final JsonObject vTunnel) {
 211                 LOG.trace("Start VTunnelResourceValidator#commonValidations()");
 212                 // validation for key: description(optional)
 213                 setInvalidParameter(VtnServiceJsonConsts.DESCRIPTION);
 214                 if (vTunnel.has(VtnServiceJsonConsts.DESCRIPTION)
 215                                 && vTunnel.getAsJsonPrimitive(
 216                                                 VtnServiceJsonConsts.DESCRIPTION).getAsString() != null) {
 217                         isValid = validator.isValidMaxLength(
 218                                         vTunnel.getAsJsonPrimitive(
 219                                                         VtnServiceJsonConsts.DESCRIPTION)
 220                                                         .getAsString().trim(),
 221                                                         VtnServiceJsonConsts.LEN_127)
 222                                                         || vTunnel
 223                                                         .getAsJsonPrimitive(
 224                                                                         VtnServiceJsonConsts.DESCRIPTION)
 225                                                                         .getAsString().trim().isEmpty();
 226                 }
 227                 // validation for key: vtn_name(optional)
 228                 if (isValid) {
 229                         setInvalidParameter(VtnServiceJsonConsts.VTNNAME);
 230                         if (vTunnel.has(VtnServiceJsonConsts.VTNNAME)
 231                                         && vTunnel.getAsJsonPrimitive(
 232                                                         VtnServiceJsonConsts.VTNNAME).getAsString() != null) {
 233                                 isValid = validator.isValidMaxLengthAlphaNum(vTunnel
 234                                                 .getAsJsonPrimitive(VtnServiceJsonConsts.VTNNAME)
 235                                                 .getAsString().trim(), VtnServiceJsonConsts.LEN_31)
 236                                                 || vTunnel
 237                                                 .getAsJsonPrimitive(
 238                                                                 VtnServiceJsonConsts.VTNNAME)
 239                                                                 .getAsString().trim().isEmpty();
 240                         }
 241                 }
 242                 // validation for key: vtepgroup_name(optional)
 243                 if (isValid) {
 244                         setInvalidParameter(VtnServiceJsonConsts.VTEPGROUPNAME);
 245                         if (vTunnel.has(VtnServiceJsonConsts.VTEPGROUPNAME)
 246                                         && vTunnel.getAsJsonPrimitive(
 247                                                         VtnServiceJsonConsts.VTEPGROUPNAME)
 248                                                         .getAsString() != null) {
 249                                 isValid = validator.isValidMaxLengthAlphaNum(
 250                                                 vTunnel.getAsJsonPrimitive(
 251                                                                 VtnServiceJsonConsts.VTEPGROUPNAME)
 252                                                                 .getAsString().trim(),
 253                                                                 VtnServiceJsonConsts.LEN_31)
 254                                                                 || vTunnel
 255                                                                 .getAsJsonPrimitive(
 256                                                                                 VtnServiceJsonConsts.VTEPGROUPNAME)
 257                                                                                 .getAsString().trim().isEmpty();
 258                         }
 259                 }
 260                 // validation for key: label(optional)
 261                 if (isValid) {
 262                         setInvalidParameter(VtnServiceJsonConsts.LABEL);
 263                         if (isValid && vTunnel.has(VtnServiceJsonConsts.LABEL)) {
 264                                 isValid = validator.isValidRange(
 265                                                 vTunnel.getAsJsonPrimitive(VtnServiceJsonConsts.LABEL)
 266                                                                 .getAsString().trim(),
 267                                                 VtnServiceJsonConsts.LONG_VAL_0,
 268                                                 VtnServiceJsonConsts.LONG_VAL_4294967295);
 269                         }
 270                 }
 271                 LOG.trace("complete VTunnelResourceValidator#commonValidations()");
 272                 return isValid;
 273         }
 274
 275         /**
 276          * Validate put request Json object for VTunnelResource
 277          *
 278          * @param requestBody
 279          *            the request Json object
 280          * @return true, if successful
 281          * @throws VtnServiceException
 282          *             the vtn service exception
 283          */
 284         private boolean validatePut(final JsonObject requestBody)
 285                         throws VtnServiceException {
 286                 LOG.trace("Start VTunnelResourceValidator#validatePost()");
 287                 boolean isValid = false;
 288                 setInvalidParameter(VtnServiceJsonConsts.VTUNNEL);
 289                 if (requestBody.has(VtnServiceJsonConsts.VTUNNEL)
 290                                 && requestBody.get(VtnServiceJsonConsts.VTUNNEL).isJsonObject()) {
 291                         isValid = true;
 292                         final JsonObject vTunnel = requestBody
 293                                         .getAsJsonObject(VtnServiceJsonConsts.VTUNNEL);
 294                         // validation for key: description(optional),  vtn_name(optional), vtepgroup_name(optional), label(optional)
 295                         isValid = commonValidations(isValid, vTunnel);
 296                         // validation for key: controller_id(optional)
 297                         if (isValid) {
 298                                 setInvalidParameter(VtnServiceJsonConsts.CONTROLLERID);
 299                                 if (vTunnel.has(VtnServiceJsonConsts.CONTROLLERID)
 300                                                 && vTunnel.getAsJsonPrimitive(
 301                                                                 VtnServiceJsonConsts.CONTROLLERID)
 302                                                                 .getAsString() != null && !vTunnel
 303                                                                 .getAsJsonPrimitive(
 304                                                                                 VtnServiceJsonConsts.CONTROLLERID)
 305                                                                                 .getAsString().trim().isEmpty()) {
 306                                         isValid = validator.isValidMaxLengthAlphaNum(
 307                                                         vTunnel.getAsJsonPrimitive(
 308                                                                         VtnServiceJsonConsts.CONTROLLERID)
 309                                                                         .getAsString().trim(),
 310                                                                         VtnServiceJsonConsts.LEN_31);
 311                                 }
 312                         }
 313                         // validation for key: DomainId(optional)
 314                         if (isValid) {
 315                                 setInvalidParameter(VtnServiceJsonConsts.DOMAINID);
 316                                 if (vTunnel.has(VtnServiceJsonConsts.DOMAINID)
 317                                                 && vTunnel.getAsJsonPrimitive(
 318                                                                 VtnServiceJsonConsts.DOMAINID).getAsString() != null && !vTunnel
 319                                                                 .getAsJsonPrimitive(
 320                                                                                 VtnServiceJsonConsts.DOMAINID)
 321                                                                                 .getAsString().trim().isEmpty()) {
 322                                         isValid = validator.isValidDomainId(vTunnel
 323                                                         .getAsJsonPrimitive(VtnServiceJsonConsts.DOMAINID)
 324                                                         .getAsString().trim(), VtnServiceJsonConsts.LEN_31);
 325                                 }
 326                         }
 327                 }
 328                 LOG.trace("Complete VTunnelResourceValidator#validatePost()");
 329                 return isValid;
 330         }
 331 }