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.FlowListEntriesResource;
  19 import org.opendaylight.vtn.javaapi.resources.logical.FlowListEntryResource;
  20 import org.opendaylight.vtn.javaapi.validation.CommonValidator;
  21 import org.opendaylight.vtn.javaapi.validation.VtnServiceValidator;
  22
  23 /**
  24  * The Class FlowListEntryResourceValidator validates request Json object for
  25  * FlowListEntry API.
  26  */
  27 public class FlowListEntryResourceValidator extends VtnServiceValidator {
  28
  29         private static final Logger LOG = Logger
  30                         .getLogger(FlowListEntryResourceValidator.class.getName());
  31         private final AbstractResource resource;
  32         final CommonValidator validator = new CommonValidator();
  33
  34         /**
  35          * Instantiates a new flow list entry resource validator.
  36          *
  37          * @param resource
  38          *            the instance of AbstractResource
  39          */
  40         public FlowListEntryResourceValidator(final AbstractResource resource) {
  41                 this.resource = resource;
  42         }
  43
  44         /**
  45          * Validate uri parameters for FlowListEntry API.
  46          *
  47          * @return true, if successful
  48          */
  49         @Override
  50         public boolean validateUri() {
  51                 LOG.trace("Start FlowListEntryResourceValidator#validateUri()");
  52                 boolean isValid = false;
  53                 setInvalidParameter(VtnServiceJsonConsts.URI
  54                                 + VtnServiceJsonConsts.FLNAME);
  55                 if (resource instanceof FlowListEntryResource
  56                                 && ((FlowListEntryResource) resource).getFlName() != null
  57                                 && !((FlowListEntryResource) resource).getFlName().trim()
  58                                                 .isEmpty()) {
  59                         isValid = validator.isValidMaxLengthAlphaNum(
  60                                         ((FlowListEntryResource) resource).getFlName().trim(),
  61                                         VtnServiceJsonConsts.LEN_32);
  62                         if (isValid) {
  63                                 setInvalidParameter(VtnServiceJsonConsts.URI
  64                                                 + VtnServiceJsonConsts.SEQNUM);
  65                                 if (((FlowListEntryResource) resource).getSeqnum() != null
  66                                                 && !((FlowListEntryResource) resource).getSeqnum()
  67                                                                 .trim().isEmpty()) {
  68                                         isValid = validator.isValidRange(((FlowListEntryResource) resource)
  69                                                                         .getSeqnum().trim(),
  70                                                         VtnServiceJsonConsts.VAL_1,
  71                                                         VtnServiceJsonConsts.VAL_65535);
  72                                 } else {
  73                                         isValid = false;
  74                                 }
  75                         }
  76                         setListOpFlag(false);
  77                 } else if (resource instanceof FlowListEntriesResource
  78                                 && ((FlowListEntriesResource) resource).getFlName() != null
  79                                 && !((FlowListEntriesResource) resource).getFlName().trim()
  80                                                 .isEmpty()) {
  81                         isValid = validator.isValidMaxLengthAlphaNum(
  82                                         ((FlowListEntriesResource) resource).getFlName().trim(),
  83                                         VtnServiceJsonConsts.LEN_32);
  84                         setListOpFlag(true);
  85                 }
  86                 LOG.trace("Start FlowListEntryResourceValidator#validateUri()");
  87                 return isValid;
  88         }
  89
  90         /**
  91          * Validate request Json object for get, put and post method of
  92          * FlowListEntry API
  93          */
  94         @Override
  95         public void validate(final String method, final JsonObject requestBody)
  96                         throws VtnServiceException {
  97                 LOG.trace("Start FlowListEntryResourceValidator#validate()");
  98                 LOG.info("Validating request for " + method
  99                                 + " of FlowListEntryResourceValidator");
 100                 boolean isValid = false;
 101                 try {
 102                         isValid = validateUri();
 103                         if (isValid && requestBody != null
 104                                         && VtnServiceConsts.GET.equals(method)) {
 105                                 isValid = validator.isValidGetForIntIndex(requestBody,
 106                                                 isListOpFlag());
 107                                 setInvalidParameter(validator.getInvalidParameter());
 108                                 updateOpParameterForList(requestBody);
 109                         } else if (isValid && requestBody != null
 110                                         && VtnServiceConsts.PUT.equals(method)) {
 111                                 isValid = validatePut(requestBody);
 112                         } else if (isValid && requestBody != null
 113                                         && VtnServiceConsts.POST.equals(method)) {
 114                                 isValid = validatePost(requestBody);
 115                         } else if (isValid) {
 116                                 setInvalidParameter(VtnServiceConsts.INCORRECT_METHOD_INVOCATION);
 117                                 isValid = false;
 118                         }
 119                 } catch (final NumberFormatException e) {
 120                         if (method.equals(VtnServiceConsts.GET)) {
 121                                 setInvalidParameter(validator.getInvalidParameter());
 122                         }
 123                         LOG.error("Inside catch:NumberFormatException");
 124                         isValid = false;
 125                 } catch (final ClassCastException e) {
 126                         if (method.equals(VtnServiceConsts.GET)) {
 127                                 setInvalidParameter(validator.getInvalidParameter());
 128                         }
 129                         LOG.error("Inside catch:ClassCastException");
 130                         isValid = false;
 131                 }
 132                 // Throws exception if validation fails
 133                 if (!isValid) {
 134                         LOG.error("Validation failed");
 135                         throw new VtnServiceException(Thread.currentThread()
 136                                         .getStackTrace()[1].getMethodName(),
 137                                         UncJavaAPIErrorCode.VALIDATION_ERROR.getErrorCode(),
 138                                         UncJavaAPIErrorCode.VALIDATION_ERROR.getErrorMessage());
 139                 }
 140                 LOG.info("Validation successful");
 141                 LOG.trace("Complete FlowListEntryResourceValidator#validate()");
 142         }
 143
 144         /**
 145          * Validate put request Json object for FlowListEntry API
 146          *
 147          * @param requestBody
 148          *            the request Json object
 149          * @return true, if successful
 150          */
 151         private boolean validatePut(final JsonObject requestBody) {
 152                 LOG.trace("Start FlowListEntryResourceValidator#validatePut()");
 153                 boolean isValid = false;
 154                 setInvalidParameter(VtnServiceJsonConsts.FLOWLISTENTRY);
 155                 if (requestBody.has(VtnServiceJsonConsts.FLOWLISTENTRY)
 156                                 && requestBody.get(VtnServiceJsonConsts.FLOWLISTENTRY)
 157                                                 .isJsonObject()) {
 158                         isValid = true;
 159                         final JsonObject flowListEntry = requestBody
 160                                         .getAsJsonObject(VtnServiceJsonConsts.FLOWLISTENTRY);
 161                         // validation for key: macdstaddr(optional)
 162                         if (isValid) {
 163                                 setInvalidParameter(VtnServiceJsonConsts.MACDSTADDR);
 164                                 if (flowListEntry.has(VtnServiceJsonConsts.MACDSTADDR)
 165                                                 && flowListEntry.getAsJsonPrimitive(
 166                                                                 VtnServiceJsonConsts.MACDSTADDR).getAsString() != null) {
 167                                         isValid = validator
 168                                                         .isValidMacAddress(flowListEntry
 169                                                                         .getAsJsonPrimitive(
 170                                                                                         VtnServiceJsonConsts.MACDSTADDR)
 171                                                                         .getAsString().trim());
 172                                 }
 173                         }
 174                         // validation for key: macsrcaddr
 175                         if (isValid) {
 176                                 setInvalidParameter(VtnServiceJsonConsts.MACSRCADDR);
 177                                 if (flowListEntry.has(VtnServiceJsonConsts.MACSRCADDR)
 178                                                 && flowListEntry.getAsJsonPrimitive(
 179                                                                 VtnServiceJsonConsts.MACSRCADDR).getAsString() != null) {
 180                                         isValid = validator
 181                                                         .isValidMacAddress(flowListEntry
 182                                                                         .getAsJsonPrimitive(
 183                                                                                         VtnServiceJsonConsts.MACSRCADDR)
 184                                                                         .getAsString().trim());
 185                                 }
 186                         }
 187                         // validation for key: macethertype
 188                         if (isValid) {
 189                                 setInvalidParameter(VtnServiceJsonConsts.MACETHERTYPE);
 190                                 if (flowListEntry.has(VtnServiceJsonConsts.MACETHERTYPE)
 191                                                 && flowListEntry.getAsJsonPrimitive(
 192                                                                 VtnServiceJsonConsts.MACETHERTYPE)
 193                                                                 .getAsString() != null) {
 194                                         isValid = validator.isValidEtherType(flowListEntry
 195                                                         .getAsJsonPrimitive(
 196                                                                         VtnServiceJsonConsts.MACETHERTYPE)
 197                                                         .getAsString().trim());
 198                                 }
 199                         }
 200                         // validation for key: macvlanpriority
 201                         if (isValid) {
 202                                 setInvalidParameter(VtnServiceJsonConsts.MACVLANPRIORITY);
 203                                 if (flowListEntry.has(VtnServiceJsonConsts.MACVLANPRIORITY)
 204                                                 && flowListEntry.getAsJsonPrimitive(
 205                                                                 VtnServiceJsonConsts.MACVLANPRIORITY)
 206                                                                 .getAsString() != null) {
 207                                         isValid = validator
 208                                                         .isValidRange(
 209                                                                         flowListEntry
 210                                                                                         .getAsJsonPrimitive(
 211                                                                                                         VtnServiceJsonConsts.MACVLANPRIORITY)
 212                                                                                         .getAsString().trim(),
 213                                                                         VtnServiceJsonConsts.VAL_0,
 214                                                                         VtnServiceJsonConsts.VAL_7);
 215                                 }
 216                         }
 217                         // validation for key: ipdstaddr
 218                         if (isValid) {
 219                                 setInvalidParameter(VtnServiceJsonConsts.IPDSTADDR);
 220                                 if (flowListEntry.has(VtnServiceJsonConsts.IPDSTADDR)
 221                                                 && flowListEntry.getAsJsonPrimitive(
 222                                                                 VtnServiceJsonConsts.IPDSTADDR).getAsString() != null) {
 223                                         isValid = validator.isValidIpV4(flowListEntry
 224                                                         .getAsJsonPrimitive(VtnServiceJsonConsts.IPDSTADDR)
 225                                                         .getAsString().trim());
 226                                 }
 227                         }
 228                         // validation for key: ipdstaddrprefix
 229                         if (isValid) {
 230                                 setInvalidParameter(VtnServiceJsonConsts.IPDSTADDRPREFIX);
 231                                 if (flowListEntry.has(VtnServiceJsonConsts.IPDSTADDRPREFIX)
 232                                                 && flowListEntry.getAsJsonPrimitive(
 233                                                                 VtnServiceJsonConsts.IPDSTADDRPREFIX)
 234                                                                 .getAsString() != null) {
 235                                         isValid = validator
 236                                                         .isValidRange(
 237                                                                         flowListEntry
 238                                                                                         .getAsJsonPrimitive(
 239                                                                                                         VtnServiceJsonConsts.IPDSTADDRPREFIX)
 240                                                                                         .getAsString().trim(),
 241                                                                         VtnServiceJsonConsts.VAL_1,
 242                                                                         VtnServiceJsonConsts.VAL_32);
 243                                 }
 244                         }
 245                         // validation for key: ipsrcaddr
 246                         if (isValid) {
 247                                 setInvalidParameter(VtnServiceJsonConsts.IPSRCADDR);
 248                                 if (flowListEntry.has(VtnServiceJsonConsts.IPSRCADDR)
 249                                                 && flowListEntry.getAsJsonPrimitive(
 250                                                                 VtnServiceJsonConsts.IPSRCADDR).getAsString() != null) {
 251                                         isValid = validator.isValidIpV4(flowListEntry
 252                                                         .getAsJsonPrimitive(VtnServiceJsonConsts.IPSRCADDR)
 253                                                         .getAsString().trim());
 254                                 }
 255                         }
 256                         // validation for key: ipsrcaddrprefix
 257                         if (isValid) {
 258                                 setInvalidParameter(VtnServiceJsonConsts.IPSRCADDRPREFIX);
 259                                 if (flowListEntry.has(VtnServiceJsonConsts.IPSRCADDRPREFIX)
 260                                                 && flowListEntry.getAsJsonPrimitive(
 261                                                                 VtnServiceJsonConsts.IPSRCADDRPREFIX)
 262                                                                 .getAsString() != null) {
 263                                         isValid = validator
 264                                                         .isValidRange(
 265                                                                         flowListEntry
 266                                                                                         .getAsJsonPrimitive(
 267                                                                                                         VtnServiceJsonConsts.IPSRCADDRPREFIX)
 268                                                                                         .getAsString().trim(),
 269                                                                         VtnServiceJsonConsts.VAL_1,
 270                                                                         VtnServiceJsonConsts.VAL_32);
 271                                 }
 272                         }
 273                         // validation for key: ipv6dstaddr"
 274                         if (isValid) {
 275                                 setInvalidParameter(VtnServiceJsonConsts.IPV6DSTADDR);
 276                                 if (flowListEntry.has(VtnServiceJsonConsts.IPV6DSTADDR)
 277                                                 && flowListEntry.getAsJsonPrimitive(
 278                                                                 VtnServiceJsonConsts.IPV6DSTADDR).getAsString() != null) {
 279                                         isValid = validator.isValidIpV6(flowListEntry
 280                                                         .getAsJsonPrimitive(
 281                                                                         VtnServiceJsonConsts.IPV6DSTADDR)
 282                                                         .getAsString().trim());
 283                                 }
 284                         }
 285                         // validation for key: ipv6dstaddrprefix
 286                         if (isValid) {
 287                                 setInvalidParameter(VtnServiceJsonConsts.IPV6DSTADDRPREFIX);
 288                                 if (flowListEntry.has(VtnServiceJsonConsts.IPV6DSTADDRPREFIX)
 289                                                 && flowListEntry.getAsJsonPrimitive(
 290                                                                 VtnServiceJsonConsts.IPV6DSTADDRPREFIX)
 291                                                                 .getAsString() != null) {
 292                                         isValid = validator
 293                                                         .isValidRange(
 294                                                                         flowListEntry
 295                                                                                         .getAsJsonPrimitive(
 296                                                                                                         VtnServiceJsonConsts.IPV6DSTADDRPREFIX)
 297                                                                                         .getAsString().trim(),
 298                                                                         VtnServiceJsonConsts.VAL_1,
 299                                                                         VtnServiceJsonConsts.VAL_128);
 300                                 }
 301                         }
 302                         // validation for key: ipv6srcaddr
 303                         if (isValid) {
 304                                 setInvalidParameter(VtnServiceJsonConsts.IPV6SRCADDR);
 305                                 if (flowListEntry.has(VtnServiceJsonConsts.IPV6SRCADDR)
 306                                                 && flowListEntry.getAsJsonPrimitive(
 307                                                                 VtnServiceJsonConsts.IPV6SRCADDR).getAsString() != null) {
 308                                         isValid = validator.isValidIpV6(flowListEntry
 309                                                         .getAsJsonPrimitive(
 310                                                                         VtnServiceJsonConsts.IPV6SRCADDR)
 311                                                         .getAsString().trim());
 312                                 }
 313                         }
 314                         // validation for key: ipv6srcaddrprefix
 315                         if (isValid) {
 316                                 setInvalidParameter(VtnServiceJsonConsts.IPV6SRCADDRPREFIX);
 317                                 if (flowListEntry.has(VtnServiceJsonConsts.IPV6SRCADDRPREFIX)
 318                                                 && flowListEntry.getAsJsonPrimitive(
 319                                                                 VtnServiceJsonConsts.IPV6SRCADDRPREFIX)
 320                                                                 .getAsString() != null) {
 321                                         isValid = validator
 322                                                         .isValidRange(
 323                                                                         flowListEntry
 324                                                                                         .getAsJsonPrimitive(
 325                                                                                                         VtnServiceJsonConsts.IPV6SRCADDRPREFIX)
 326                                                                                         .getAsString().trim(),
 327                                                                         VtnServiceJsonConsts.VAL_1,
 328                                                                         VtnServiceJsonConsts.VAL_128);
 329                                 }
 330                         }
 331                         // validation for key: ipproto
 332                         if (isValid) {
 333                                 setInvalidParameter(VtnServiceJsonConsts.IPPROTO);
 334                                 if (flowListEntry.has(VtnServiceJsonConsts.IPPROTO)
 335                                                 && flowListEntry.getAsJsonPrimitive(
 336                                                                 VtnServiceJsonConsts.IPPROTO).getAsString() != null) {
 337                                         isValid = validator.isValidRange(
 338                                                         flowListEntry
 339                                                                         .getAsJsonPrimitive(
 340                                                                                         VtnServiceJsonConsts.IPPROTO)
 341                                                                         .getAsString().trim(),
 342                                                         VtnServiceJsonConsts.VAL_1,
 343                                                         VtnServiceJsonConsts.VAL_255);
 344                                 }
 345                         }
 346                         // validation for key: ipdscp
 347                         if (isValid) {
 348                                 setInvalidParameter(VtnServiceJsonConsts.IPDSCP);
 349                                 if (flowListEntry.has(VtnServiceJsonConsts.IPDSCP)
 350                                                 && flowListEntry.getAsJsonPrimitive(
 351                                                                 VtnServiceJsonConsts.IPDSCP).getAsString() != null) {
 352                                         isValid = validator.isValidRange(
 353                                                         flowListEntry
 354                                                                         .getAsJsonPrimitive(
 355                                                                                         VtnServiceJsonConsts.IPDSCP)
 356                                                                         .getAsString().trim(),
 357                                                         VtnServiceJsonConsts.VAL_0,
 358                                                         VtnServiceJsonConsts.VAL_63);
 359                                 }
 360                         }
 361                         // validation for key: l4dstport
 362                         if (isValid) {
 363                                 setInvalidParameter(VtnServiceJsonConsts.L4DSTPORT);
 364                                 if (flowListEntry.has(VtnServiceJsonConsts.L4DSTPORT)
 365                                                 && flowListEntry.getAsJsonPrimitive(
 366                                                                 VtnServiceJsonConsts.L4DSTPORT).getAsString() != null) {
 367                                         isValid = validator.isValidRange(
 368                                                         flowListEntry
 369                                                                         .getAsJsonPrimitive(
 370                                                                                         VtnServiceJsonConsts.L4DSTPORT)
 371                                                                         .getAsString().trim(),
 372                                                         VtnServiceJsonConsts.VAL_0,
 373                                                         VtnServiceJsonConsts.VAL_65535);
 374                                 }
 375                         }
 376                         // validation for key: l4dstendport
 377                         if (isValid) {
 378                                 setInvalidParameter(VtnServiceJsonConsts.L4DSTENDPORT);
 379                                 if (flowListEntry.has(VtnServiceJsonConsts.L4DSTENDPORT)
 380                                                 && flowListEntry.getAsJsonPrimitive(
 381                                                                 VtnServiceJsonConsts.L4DSTENDPORT)
 382                                                                 .getAsString() != null) {
 383                                         isValid = validator.isValidRange(
 384                                                         flowListEntry
 385                                                                         .getAsJsonPrimitive(
 386                                                                                         VtnServiceJsonConsts.L4DSTENDPORT)
 387                                                                         .getAsString().trim(),
 388                                                         VtnServiceJsonConsts.VAL_1,
 389                                                         VtnServiceJsonConsts.VAL_65535);
 390                                 }
 391                         }
 392                         // validation for key: l4srcport
 393                         if (isValid) {
 394                                 setInvalidParameter(VtnServiceJsonConsts.L4SRCPORT);
 395                                 if (flowListEntry.has(VtnServiceJsonConsts.L4SRCPORT)
 396                                                 && flowListEntry.getAsJsonPrimitive(
 397                                                                 VtnServiceJsonConsts.L4SRCPORT).getAsString() != null) {
 398                                         isValid = validator.isValidRange(
 399                                                         flowListEntry
 400                                                                         .getAsJsonPrimitive(
 401                                                                                         VtnServiceJsonConsts.L4SRCPORT)
 402                                                                         .getAsString().trim(),
 403                                                         VtnServiceJsonConsts.VAL_0,
 404
 405                                                         VtnServiceJsonConsts.VAL_65535);
 406                                 }
 407                         }
 408                         // validation for key: l4srcendport
 409                         if (isValid) {
 410                                 setInvalidParameter(VtnServiceJsonConsts.L4SRCENDPORT);
 411                                 if (flowListEntry.has(VtnServiceJsonConsts.L4SRCENDPORT)
 412                                                 && flowListEntry.getAsJsonPrimitive(
 413                                                                 VtnServiceJsonConsts.L4SRCENDPORT)
 414                                                                 .getAsString() != null) {
 415                                         isValid = validator.isValidRange(
 416                                                         flowListEntry
 417                                                                         .getAsJsonPrimitive(
 418                                                                                         VtnServiceJsonConsts.L4SRCENDPORT)
 419                                                                         .getAsString().trim(),
 420                                                         VtnServiceJsonConsts.VAL_1,
 421                                                         VtnServiceJsonConsts.VAL_65535);
 422                                 }
 423                         }
 424                         // validation for key: icmptypenum
 425                         if (isValid) {
 426                                 setInvalidParameter(VtnServiceJsonConsts.ICMPTYPENUM);
 427                                 if (flowListEntry.has(VtnServiceJsonConsts.ICMPTYPENUM)
 428                                                 && flowListEntry.getAsJsonPrimitive(
 429                                                                 VtnServiceJsonConsts.ICMPTYPENUM).getAsString() != null) {
 430                                         isValid = validator.isValidRange(
 431                                                         flowListEntry
 432                                                                         .getAsJsonPrimitive(
 433                                                                                         VtnServiceJsonConsts.ICMPTYPENUM)
 434                                                                         .getAsString().trim(),
 435                                                         VtnServiceJsonConsts.VAL_0,
 436                                                         VtnServiceJsonConsts.VAL_255);
 437                                 }
 438                         }
 439                         // validation for key: icmpcodenum
 440                         if (isValid) {
 441                                 setInvalidParameter(VtnServiceJsonConsts.ICMPCODENUM);
 442                                 if (flowListEntry.has(VtnServiceJsonConsts.ICMPCODENUM)
 443                                                 && flowListEntry.getAsJsonPrimitive(
 444                                                                 VtnServiceJsonConsts.ICMPCODENUM).getAsString() != null) {
 445                                         isValid = validator.isValidRange(
 446                                                         flowListEntry
 447                                                                         .getAsJsonPrimitive(
 448                                                                                         VtnServiceJsonConsts.ICMPCODENUM)
 449                                                                         .getAsString().trim(),
 450                                                         VtnServiceJsonConsts.VAL_0,
 451                                                         VtnServiceJsonConsts.VAL_255);
 452                                 }
 453                         }
 454                         // validation for key: ipv6icmptypenum
 455                         if (isValid) {
 456                                 setInvalidParameter(VtnServiceJsonConsts.IPV6ICMPTYPENUM);
 457                                 if (flowListEntry.has(VtnServiceJsonConsts.IPV6ICMPTYPENUM)
 458                                                 && flowListEntry.getAsJsonPrimitive(
 459                                                                 VtnServiceJsonConsts.IPV6ICMPTYPENUM)
 460                                                                 .getAsString() != null) {
 461                                         isValid = validator
 462                                                         .isValidRange(
 463                                                                         flowListEntry
 464                                                                                         .getAsJsonPrimitive(
 465                                                                                                         VtnServiceJsonConsts.IPV6ICMPTYPENUM)
 466                                                                                         .getAsString().trim(),
 467                                                                         VtnServiceJsonConsts.VAL_0,
 468                                                                         VtnServiceJsonConsts.VAL_255);
 469                                 }
 470                         }
 471                         // validation for key: ipv6icmpcodenum
 472                         if (isValid) {
 473                                 setInvalidParameter(VtnServiceJsonConsts.IPV6ICMPCODENUM);
 474                                 if (flowListEntry.has(VtnServiceJsonConsts.IPV6ICMPCODENUM)
 475                                                 && flowListEntry.getAsJsonPrimitive(
 476                                                                 VtnServiceJsonConsts.IPV6ICMPCODENUM)
 477                                                                 .getAsString() != null) {
 478                                         isValid = validator
 479                                                         .isValidRange(
 480                                                                         flowListEntry
 481                                                                                         .getAsJsonPrimitive(
 482                                                                                                         VtnServiceJsonConsts.IPV6ICMPCODENUM)
 483                                                                                         .getAsString().trim(),
 484                                                                         VtnServiceJsonConsts.VAL_0,
 485                                                                         VtnServiceJsonConsts.VAL_255);
 486                                 }
 487                         }
 488                 }
 489                 LOG.trace("Complete FlowListEntryResourceValidator#validatePut()");
 490                 return isValid;
 491         }
 492
 493         /**
 494          * Validate post request Json object for FlowListEntryresource
 495          *
 496          * @param requestBody
 497          *            the request Json object
 498          * @return true, if successful
 499          * @throws VtnServiceException
 500          *             the vtn service exception
 501          */
 502         private boolean validatePost(final JsonObject requestBody)
 503                         throws VtnServiceException {
 504                 LOG.trace("Start FlowListEntryResourceValidator#validatePost()");
 505                 boolean isValid = false;
 506                 setInvalidParameter(VtnServiceJsonConsts.FLOWLISTENTRY);
 507                 if (requestBody.has(VtnServiceJsonConsts.FLOWLISTENTRY)
 508                                 && requestBody.get(VtnServiceJsonConsts.FLOWLISTENTRY)
 509                                                 .isJsonObject()) {
 510                         final JsonObject flowListEntry = requestBody
 511                                         .getAsJsonObject(VtnServiceJsonConsts.FLOWLISTENTRY);
 512                         // validation for key: seqnum
 513                         setInvalidParameter(VtnServiceJsonConsts.SEQNUM);
 514                         if (flowListEntry.has(VtnServiceJsonConsts.SEQNUM)
 515                                         && flowListEntry.getAsJsonPrimitive(
 516                                                         VtnServiceJsonConsts.SEQNUM).getAsString() != null) {
 517                                 isValid = validator.isValidRange(flowListEntry
 518                                                 .getAsJsonPrimitive(VtnServiceJsonConsts.SEQNUM)
 519                                                 .getAsString().trim(), VtnServiceJsonConsts.VAL_1,
 520                                                 VtnServiceJsonConsts.VAL_65535);
 521                         }
 522                         if (isValid) {
 523                                 isValid = validatePut(requestBody);
 524                         }
 525
 526                 }
 527                 LOG.trace("Complete FlowListEntryResourceValidator#validatePost()");
 528                 return isValid;
 529         }
 530 }