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.DomainLogicalPortResource;
  19 import org.opendaylight.vtn.javaapi.resources.physical.DomainLogicalPortsResource;
  20 import org.opendaylight.vtn.javaapi.validation.CommonValidator;
  21 import org.opendaylight.vtn.javaapi.validation.VtnServiceValidator;
  22
  23 /**
  24  * The Class DomainLogicalPortResourceValidator validates get method of Logical
  25  * Port API.
  26  */
  27 public class DomainLogicalPortResourceValidator extends VtnServiceValidator {
  28
  29         private static final Logger LOG = Logger
  30                         .getLogger(DomainLogicalPortResourceValidator.class.getName());
  31
  32         private final AbstractResource resource;
  33         final CommonValidator validator = new CommonValidator();
  34
  35         /**
  36          * Instantiates a new DomainLogicalPort resource validator.
  37          *
  38          * @param resource
  39          *            the instance of AbstractResource
  40          */
  41         public DomainLogicalPortResourceValidator(final AbstractResource resource) {
  42                 this.resource = resource;
  43         }
  44
  45         /**
  46          * Validate uri parameters for DomainLogicalPort API
  47          *
  48          * @return true, if successful
  49          */
  50         @Override
  51         public boolean validateUri() {
  52                 LOG.trace("Start DomainLogicalPortResourceValidator#validateUri()");
  53                 boolean isValid = false;
  54                 setInvalidParameter(VtnServiceJsonConsts.URI
  55                                 + VtnServiceJsonConsts.CONTROLLERID);
  56                 if (resource instanceof DomainLogicalPortResource
  57                                 && ((DomainLogicalPortResource) resource).getControllerId() != null
  58                                 && !((DomainLogicalPortResource) resource).getControllerId()
  59                                                 .trim().isEmpty()) {
  60                         isValid = validator.isValidMaxLengthAlphaNum(
  61                                         ((DomainLogicalPortResource) resource).getControllerId()
  62                                                         .trim(), VtnServiceJsonConsts.LEN_31);
  63                         if (isValid) {
  64                                 setInvalidParameter(VtnServiceJsonConsts.URI
  65                                                 + VtnServiceJsonConsts.DOMAINID);
  66                                 if (((DomainLogicalPortResource) resource).getDomainId() != null
  67                                                 && !((DomainLogicalPortResource) resource)
  68                                                                 .getDomainId().trim().isEmpty()) {
  69                                         isValid = validator.isValidDomainId(
  70                                                         ((DomainLogicalPortResource) resource)
  71                                                                         .getDomainId().trim(),
  72                                                         VtnServiceJsonConsts.LEN_31);
  73                                 } else {
  74                                         isValid = false;
  75                                 }
  76                         }
  77                         if (isValid) {
  78                                 setInvalidParameter(VtnServiceJsonConsts.URI
  79                                                 + VtnServiceJsonConsts.LOGICAL_PORT_ID);
  80                                 if (((DomainLogicalPortResource) resource).getLogicalPortId() != null
  81                                                 && !((DomainLogicalPortResource) resource)
  82                                                                 .getLogicalPortId().trim().isEmpty()) {
  83                                         isValid = validator.isValidMaxLength(
  84                                                         ((DomainLogicalPortResource) resource)
  85                                                                         .getLogicalPortId().trim(),
  86                                                         VtnServiceJsonConsts.LEN_319);
  87                                 } else {
  88                                         isValid = false;
  89                                 }
  90                         }
  91                         setListOpFlag(false);
  92                 } else if (resource instanceof DomainLogicalPortsResource) {
  93                         if (((DomainLogicalPortsResource) resource).getcontrollerId() != null
  94                                         && !((DomainLogicalPortsResource) resource)
  95                                                         .getcontrollerId().trim().isEmpty()) {
  96                                 isValid = validator.isValidMaxLengthAlphaNum(
  97                                                 ((DomainLogicalPortsResource) resource)
  98                                                                 .getcontrollerId().trim(),
  99                                                 VtnServiceJsonConsts.LEN_31);
 100                         }
 101                         if (isValid) {
 102                                 setInvalidParameter(VtnServiceJsonConsts.URI
 103                                                 + VtnServiceJsonConsts.DOMAINID);
 104                                 if (((DomainLogicalPortsResource) resource).getdomainId() != null
 105                                                 && !((DomainLogicalPortsResource) resource)
 106                                                                 .getdomainId().trim().isEmpty()) {
 107                                         isValid = validator.isValidDomainId(
 108                                                         ((DomainLogicalPortsResource) resource)
 109                                                                         .getdomainId().trim(),
 110                                                         VtnServiceJsonConsts.LEN_31);
 111                                 } else {
 112                                         isValid = false;
 113                                 }
 114                         }
 115                         setListOpFlag(true);
 116                 }
 117                 LOG.trace("Complete DomainLogicalPortResourceValidator#validateUri()");
 118                 return isValid;
 119         }
 120
 121         @Override
 122         public void validate(final String method, final JsonObject requestBody)
 123                         throws VtnServiceException {
 124                 LOG.trace("Start DomainLogicalPortResourceValidator#validate()");
 125                 LOG.info("Validating request for " + method
 126                                 + " of DomainLogicalPortResourceValidator");
 127                 boolean isValid = false;
 128                 try {
 129                         isValid = validateUri();
 130                         if (isValid && requestBody != null
 131                                         && VtnServiceConsts.GET.equals(method)) {
 132                                 isValid = validateGet(requestBody, isListOpFlag());
 133                                 updateOpParameterForList(requestBody);
 134                         } else if (isValid) {
 135                                 setInvalidParameter(VtnServiceConsts.INCORRECT_METHOD_INVOCATION);
 136                                 isValid = false;
 137                         }
 138                 } catch (final NumberFormatException e) {
 139                         LOG.error("Inside catch:NumberFormatException");
 140                         isValid = false;
 141                 }
 142                 // Throws exception if validation fails
 143                 if (!isValid) {
 144                         LOG.error("Validation failed");
 145                         throw new VtnServiceException(Thread.currentThread()
 146                                         .getStackTrace()[1].getMethodName(),
 147                                         UncJavaAPIErrorCode.VALIDATION_ERROR.getErrorCode(),
 148                                         UncJavaAPIErrorCode.VALIDATION_ERROR.getErrorMessage());
 149                 }
 150                 LOG.info("Validation successful");
 151                 LOG.trace("Complete DomainLogicalPortResourceValidator#validate()");
 152         }
 153
 154         /**
 155          * Validate get request json for Logical Port API
 156          *
 157          * @param requestBody
 158          *            the request Json object
 159          * @return true, if successful
 160          */
 161         private boolean validateGet(final JsonObject requestBody,
 162                         final boolean opFlag) {
 163                 LOG.trace("Start DomainLogicalPortResourceValidator#validateGet()");
 164                 boolean isValid = true;
 165                 // validation for key: targetdb
 166                 setInvalidParameter(VtnServiceJsonConsts.TARGETDB);
 167                 if (requestBody.has(VtnServiceJsonConsts.TARGETDB)
 168                                 && requestBody
 169                                                 .getAsJsonPrimitive(VtnServiceJsonConsts.TARGETDB)
 170                                                 .getAsString() != null
 171                                 && !requestBody
 172                                                 .getAsJsonPrimitive(VtnServiceJsonConsts.TARGETDB)
 173                                                 .getAsString().trim().isEmpty()) {
 174                         isValid = requestBody
 175                                         .getAsJsonPrimitive(VtnServiceJsonConsts.TARGETDB)
 176                                         .getAsString().trim()
 177                                         .equalsIgnoreCase(VtnServiceJsonConsts.STATE);
 178                 } else {
 179                         requestBody.remove(VtnServiceJsonConsts.TARGETDB);
 180                         requestBody.addProperty(VtnServiceJsonConsts.TARGETDB,
 181                                         VtnServiceJsonConsts.STATE);
 182                 }
 183                 if (!opFlag) {
 184                         if (requestBody.has(VtnServiceJsonConsts.OP)) {
 185                                 requestBody.remove(VtnServiceJsonConsts.OP);
 186                         } else {
 187                                 LOG.debug("No need to remove -op ");
 188                         }
 189                         if (requestBody.has(VtnServiceJsonConsts.INDEX)) {
 190                                 requestBody.remove(VtnServiceJsonConsts.INDEX);
 191                         } else {
 192                                 LOG.debug("No need to remove - index");
 193                         }
 194                         if (requestBody.has(VtnServiceJsonConsts.MAX)) {
 195                                 requestBody.remove(VtnServiceJsonConsts.MAX);
 196                         } else {
 197                                 LOG.debug("No need to remove-max count");
 198                         }
 199                 } else {
 200                         // validation for key: op
 201                         if (isValid) {
 202                                 setInvalidParameter(VtnServiceJsonConsts.OP);
 203                                 isValid = validator.isValidOperation(requestBody);
 204                         }
 205                         // validation for key: index
 206                         if (isValid) {
 207                                 setInvalidParameter(VtnServiceJsonConsts.INDEX);
 208                                 if (requestBody.has(VtnServiceJsonConsts.INDEX)
 209                                                 && requestBody.getAsJsonPrimitive(
 210                                                                 VtnServiceJsonConsts.INDEX).getAsString() != null
 211                                                 && !requestBody
 212                                                                 .getAsJsonPrimitive(VtnServiceJsonConsts.INDEX)
 213                                                                 .getAsString().trim().isEmpty()) {
 214                                         isValid = validator
 215                                                         .isValidMaxLength(
 216                                                                         requestBody
 217                                                                                         .getAsJsonPrimitive(
 218                                                                                                         VtnServiceJsonConsts.INDEX)
 219                                                                                         .getAsString().trim(),
 220                                                                         VtnServiceJsonConsts.LEN_319);
 221                                 }
 222                         }
 223                         // validation for key: max_repitition
 224                         if (isValid) {
 225                                 setInvalidParameter(VtnServiceJsonConsts.MAX);
 226                                 isValid = validator.isValidMaxRepetition(requestBody);
 227                                 /*
 228                                  * if (requestBody.has(VtnServiceJsonConsts.MAX) &&
 229                                  * requestBody.getAsJsonPrimitive(VtnServiceJsonConsts.MAX)
 230                                  * .getAsString() != null) { isValid =
 231                                  * validator.isValidMaxLengthNumber(requestBody
 232                                  * .getAsJsonPrimitive(VtnServiceJsonConsts.MAX)
 233                                  * .getAsString().trim()); }
 234                                  */
 235                         }
 236                 }
 237                 LOG.trace("Complete DomainLogicalPortResourceValidator#isValidGet");
 238                 return isValid;
 239         }
 240 }