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