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