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