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