gerrit.opnfv Code Review - onosfw.git/blob

   1 /*
   2  * Copyright 2015 Open Networking Laboratory
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.onosproject.codec.impl;
  17
  18 import org.onosproject.codec.CodecContext;
  19 import org.onosproject.net.DeviceId;
  20 import org.onosproject.net.Link;
  21 import org.onosproject.net.intent.Constraint;
  22 import org.onosproject.net.intent.constraint.AnnotationConstraint;
  23 import org.onosproject.net.intent.constraint.BandwidthConstraint;
  24 import org.onosproject.net.intent.constraint.LambdaConstraint;
  25 import org.onosproject.net.intent.constraint.LatencyConstraint;
  26 import org.onosproject.net.intent.constraint.LinkTypeConstraint;
  27 import org.onosproject.net.intent.constraint.ObstacleConstraint;
  28 import org.onosproject.net.intent.constraint.WaypointConstraint;
  29
  30 import com.fasterxml.jackson.databind.node.ArrayNode;
  31 import com.fasterxml.jackson.databind.node.ObjectNode;
  32
  33 import static com.google.common.base.Preconditions.checkNotNull;
  34
  35 /**
  36  * Implementation of encoder for constraint JSON codec.
  37  */
  38 public final class EncodeConstraintCodecHelper {
  39
  40     private final Constraint constraint;
  41     private final CodecContext context;
  42
  43     /**
  44      * Constructs a constraint encoder.
  45      *
  46      * @param constraint constraint to encode
  47      * @param context to use for look ups
  48      */
  49     public EncodeConstraintCodecHelper(Constraint constraint, CodecContext context) {
  50         this.constraint = constraint;
  51         this.context = context;
  52     }
  53
  54     /**
  55      * Encodes a latency constraint.
  56      *
  57      * @return JSON ObjectNode representing the constraint
  58      */
  59     private ObjectNode encodeLatencyConstraint() {
  60         checkNotNull(constraint, "Duration constraint cannot be null");
  61         final LatencyConstraint latencyConstraint =
  62                 (LatencyConstraint) constraint;
  63         return context.mapper().createObjectNode()
  64                 .put("latencyMillis", latencyConstraint.latency().toMillis());
  65     }
  66
  67     /**
  68      * Encodes an obstacle constraint.
  69      *
  70      * @return JSON ObjectNode representing the constraint
  71      */
  72     private ObjectNode encodeObstacleConstraint() {
  73         checkNotNull(constraint, "Obstacle constraint cannot be null");
  74         final ObstacleConstraint obstacleConstraint =
  75                 (ObstacleConstraint) constraint;
  76
  77         final ObjectNode result = context.mapper().createObjectNode();
  78         final ArrayNode jsonObstacles = result.putArray("obstacles");
  79
  80         for (DeviceId did : obstacleConstraint.obstacles()) {
  81             jsonObstacles.add(did.toString());
  82         }
  83
  84         return result;
  85     }
  86
  87     /**
  88      * Encodes a waypoint constraint.
  89      *
  90      * @return JSON ObjectNode representing the constraint
  91      */
  92     private ObjectNode encodeWaypointConstraint() {
  93         checkNotNull(constraint, "Waypoint constraint cannot be null");
  94         final WaypointConstraint waypointConstraint =
  95                 (WaypointConstraint) constraint;
  96
  97         final ObjectNode result = context.mapper().createObjectNode();
  98         final ArrayNode jsonWaypoints = result.putArray("waypoints");
  99
 100         for (DeviceId did : waypointConstraint.waypoints()) {
 101             jsonWaypoints.add(did.toString());
 102         }
 103
 104         return result;
 105     }
 106
 107     /**
 108      * Encodes a annotation constraint.
 109      *
 110      * @return JSON ObjectNode representing the constraint
 111      */
 112     private ObjectNode encodeAnnotationConstraint() {
 113         checkNotNull(constraint, "Annotation constraint cannot be null");
 114         final AnnotationConstraint annotationConstraint =
 115                 (AnnotationConstraint) constraint;
 116         return context.mapper().createObjectNode()
 117                 .put("key", annotationConstraint.key())
 118                 .put("threshold", annotationConstraint.threshold());
 119     }
 120
 121     /**
 122      * Encodes a bandwidth constraint.
 123      *
 124      * @return JSON ObjectNode representing the constraint
 125      */
 126     private ObjectNode encodeBandwidthConstraint() {
 127         checkNotNull(constraint, "Bandwidth constraint cannot be null");
 128         final BandwidthConstraint bandwidthConstraint =
 129                 (BandwidthConstraint) constraint;
 130         return context.mapper().createObjectNode()
 131                 .put("bandwidth", bandwidthConstraint.bandwidth().toDouble());
 132     }
 133
 134     /**
 135      * Encodes a lambda constraint.
 136      *
 137      * @return JSON ObjectNode representing the constraint
 138      */
 139     private ObjectNode encodeLambdaConstraint() {
 140         checkNotNull(constraint, "Lambda constraint cannot be null");
 141         final LambdaConstraint lambdaConstraint =
 142                 (LambdaConstraint) constraint;
 143
 144         return context.mapper().createObjectNode()
 145                 .put("lambda", lambdaConstraint.lambda().toInt());
 146     }
 147
 148     /**
 149      * Encodes a link type constraint.
 150      *
 151      * @return JSON ObjectNode representing the constraint
 152      */
 153     private ObjectNode encodeLinkTypeConstraint() {
 154         checkNotNull(constraint, "Link type constraint cannot be null");
 155
 156         final LinkTypeConstraint linkTypeConstraint =
 157                 (LinkTypeConstraint) constraint;
 158
 159         final ObjectNode result = context.mapper().createObjectNode()
 160                 .put(ConstraintCodec.INCLUSIVE, linkTypeConstraint.isInclusive());
 161
 162         final ArrayNode jsonTypes = result.putArray(ConstraintCodec.TYPES);
 163
 164         if (linkTypeConstraint.types() != null) {
 165             for (Link.Type type : linkTypeConstraint.types()) {
 166                 jsonTypes.add(type.name());
 167             }
 168         }
 169
 170         return result;
 171     }
 172
 173     /**
 174      * Encodes the constraint in JSON.
 175      *
 176      * @return JSON node
 177      */
 178     public ObjectNode encode() {
 179         final ObjectNode result;
 180         if (constraint instanceof BandwidthConstraint) {
 181             result = encodeBandwidthConstraint();
 182         } else if (constraint instanceof LambdaConstraint) {
 183             result = encodeLambdaConstraint();
 184         } else if (constraint instanceof LinkTypeConstraint) {
 185             result = encodeLinkTypeConstraint();
 186         } else if (constraint instanceof AnnotationConstraint) {
 187             result = encodeAnnotationConstraint();
 188         } else if (constraint instanceof LatencyConstraint) {
 189             result = encodeLatencyConstraint();
 190         } else if (constraint instanceof ObstacleConstraint) {
 191             result = encodeObstacleConstraint();
 192         } else if (constraint instanceof WaypointConstraint) {
 193             result = encodeWaypointConstraint();
 194         } else {
 195             result = context.mapper().createObjectNode();
 196         }
 197
 198         result.put(ConstraintCodec.TYPE, constraint.getClass().getSimpleName());
 199         return result;
 200     }
 201 }