bgp/rib-impl/src/main/java/org/opendaylight/protocol/bgp/rib/impl/BestPathState.java

   1 /*
   2  * Copyright (c) 2015 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8 package org.opendaylight.protocol.bgp.rib.impl;
   9
  10 import com.google.common.annotations.VisibleForTesting;
  11 import com.google.common.base.MoreObjects;
  12 import com.google.common.base.MoreObjects.ToStringHelper;
  13 import com.google.common.base.Optional;
  14 import com.google.common.base.Preconditions;
  15 import com.google.common.cache.Cache;
  16 import com.google.common.cache.CacheBuilder;
  17 import com.google.common.collect.ImmutableList;
  18 import java.util.ArrayList;
  19 import java.util.Collection;
  20 import java.util.List;
  21 import java.util.concurrent.Callable;
  22 import java.util.concurrent.ExecutionException;
  23 import javax.annotation.concurrent.NotThreadSafe;
  24 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.AsNumber;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.path.attributes.attributes.AsPath;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.path.attributes.attributes.LocalPref;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.path.attributes.attributes.MultiExitDisc;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.path.attributes.attributes.Origin;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.path.attributes.attributes.as.path.Segments;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.path.attributes.attributes.as.path.SegmentsBuilder;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.BgpOrigin;
  32 import org.opendaylight.yangtools.yang.common.QName;
  33 import org.opendaylight.yangtools.yang.common.QNameModule;
  34 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
  35 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
  36 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
  37 import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
  38 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
  39 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
  40 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  41 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodes;
  42 import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
  43 import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
  44 import org.slf4j.Logger;
  45 import org.slf4j.LoggerFactory;
  46
  47 @NotThreadSafe
  48 final class BestPathState {
  49     private static final class NamespaceSpecificIds {
  50         private final Collection<PathArgument> asPath;
  51         private final Collection<PathArgument> locPref;
  52         private final Collection<PathArgument> med;
  53         private final Collection<PathArgument> orig;
  54         private final NodeIdentifier asSetNid;
  55         private final NodeIdentifier asSeqNid;
  56
  57         NamespaceSpecificIds(final QName namespace) {
  58             NodeIdentifier container = new NodeIdentifier(QName.cachedReference(QName.create(namespace, AsPath.QNAME.getLocalName())));
  59             NodeIdentifier leaf = new NodeIdentifier(QName.cachedReference(QName.create(namespace, "segments")));
  60             this.asPath = ImmutableList.<PathArgument>of(container, leaf);
  61
  62             container = new NodeIdentifier(QName.cachedReference(QName.create(namespace, LocalPref.QNAME.getLocalName())));
  63             leaf = new NodeIdentifier(QName.cachedReference(QName.create(namespace, "pref")));
  64             this.locPref = ImmutableList.<PathArgument>of(container, leaf);
  65
  66             container = new NodeIdentifier(QName.cachedReference(QName.create(namespace, MultiExitDisc.QNAME.getLocalName())));
  67             leaf = new NodeIdentifier(QName.cachedReference(QName.create(namespace, "med")));
  68             this.med = ImmutableList.<PathArgument>of(container, leaf);
  69
  70             container = new NodeIdentifier(QName.cachedReference(QName.create(namespace, Origin.QNAME.getLocalName())));
  71             leaf = new NodeIdentifier(QName.cachedReference(QName.create(namespace, "value")));
  72             this.orig = ImmutableList.<PathArgument>of(container, leaf);
  73
  74             this.asSetNid = new NodeIdentifier(QName.cachedReference(QName.create(namespace, "as-set")));
  75             this.asSeqNid = new NodeIdentifier(QName.cachedReference(QName.create(namespace, "as-sequence")));
  76         }
  77
  78         Collection<PathArgument> getAsPath() {
  79             return this.asPath;
  80         }
  81
  82         Collection<PathArgument> getLocPref() {
  83             return this.locPref;
  84         }
  85
  86         Collection<PathArgument> getMed() {
  87             return this.med;
  88         }
  89
  90         Collection<PathArgument> getOrig() {
  91             return this.orig;
  92         }
  93
  94         NodeIdentifier getAsSet() {
  95             return this.asSetNid;
  96         }
  97
  98         NodeIdentifier getAsSeq() {
  99             return this.asSeqNid;
 100         }
 101     }
 102
 103     private static final Logger LOG = LoggerFactory.getLogger(BestPathState.class);
 104     private static final Cache<QNameModule, NamespaceSpecificIds> PATH_CACHE = CacheBuilder.newBuilder().weakKeys().weakValues().build();
 105
 106     private long peerAs = 0L;
 107     private int asPathLength = 0;
 108
 109     private final ContainerNode attributes;
 110     private final NamespaceSpecificIds ids;
 111     private Long localPref;
 112     private Long multiExitDisc;
 113     private BgpOrigin origin;
 114     private boolean resolved;
 115
 116     BestPathState(final ContainerNode attributes) {
 117         final NamespaceSpecificIds col;
 118         try {
 119             col = PATH_CACHE.get(attributes.getNodeType().getModule(), new Callable<NamespaceSpecificIds>() {
 120                 @Override
 121                 public NamespaceSpecificIds call() {
 122                     return new NamespaceSpecificIds(attributes.getNodeType());
 123                 }
 124             });
 125         } catch (final ExecutionException e) {
 126             LOG.error("Error creating namespace-specific attributes collection.", e);
 127             throw new IllegalStateException("Error creating namespace-specific attributes collection.", e);
 128         }
 129
 130         this.attributes = Preconditions.checkNotNull(attributes);
 131         this.ids = col;
 132     }
 133
 134     private static BgpOrigin fromString(final String originStr) {
 135         switch (originStr) {
 136         case "igp":
 137             return BgpOrigin.Igp;
 138         case "egp":
 139             return BgpOrigin.Egp;
 140         case "incomplete":
 141             return BgpOrigin.Incomplete;
 142         default:
 143             throw new IllegalArgumentException("Unhandled origin value " + originStr);
 144         }
 145     }
 146
 147     private void resolveValues() {
 148         if (this.resolved) {
 149             return;
 150         }
 151
 152         final Optional<NormalizedNode<?, ?>> maybeLocalPref = NormalizedNodes.findNode(this.attributes, this.ids.getLocPref());
 153         if (maybeLocalPref.isPresent()) {
 154             this.localPref = (Long) ((LeafNode<?>)maybeLocalPref.get()).getValue();
 155         } else {
 156             this.localPref = null;
 157         }
 158
 159         final Optional<NormalizedNode<?, ?>> maybeMultiExitDisc = NormalizedNodes.findNode(this.attributes, this.ids.getMed());
 160         if (maybeMultiExitDisc.isPresent()) {
 161             this.multiExitDisc = (Long) ((LeafNode<?>)maybeMultiExitDisc.get()).getValue();
 162         } else {
 163             this.multiExitDisc = null;
 164         }
 165
 166         final Optional<NormalizedNode<?, ?>> maybeOrigin = NormalizedNodes.findNode(this.attributes, this.ids.getOrig());
 167         if (maybeOrigin.isPresent()) {
 168             this.origin = fromString((String) ((LeafNode<?>)maybeOrigin.get()).getValue());
 169         } else {
 170             this.origin = null;
 171         }
 172
 173         final Optional<NormalizedNode<?, ?>> maybeSegments = NormalizedNodes.findNode(this.attributes, this.ids.getAsPath());
 174         if (maybeSegments.isPresent()) {
 175             final UnkeyedListNode segments = (UnkeyedListNode) maybeSegments.get();
 176             final List<Segments> segs = extractSegments(segments);
 177             if (segs.size() != 0) {
 178                 this.peerAs = getPeerAs(segs).getValue();
 179                 this.asPathLength = countAsPath(segs);
 180             }
 181         }
 182         this.resolved = true;
 183     }
 184
 185     Long getLocalPref() {
 186         resolveValues();
 187         return this.localPref;
 188     }
 189
 190     Long getMultiExitDisc() {
 191         resolveValues();
 192         return this.multiExitDisc;
 193     }
 194
 195     BgpOrigin getOrigin() {
 196         resolveValues();
 197         return this.origin;
 198     }
 199
 200     Long getPeerAs() {
 201         resolveValues();
 202         return this.peerAs;
 203     }
 204
 205     int getAsPathLength() {
 206         resolveValues();
 207         return this.asPathLength;
 208     }
 209
 210     private static int countAsPath(final List<Segments> segments) {
 211         // an AS_SET counts as 1, no matter how many ASs are in the set.
 212         int count = 0;
 213         boolean setPresent = false;
 214         for (final Segments s : segments) {
 215             if (s.getAsSet() != null && !setPresent) {
 216                 setPresent = true;
 217                 count++;
 218             } else if (s.getAsSequence() != null) {
 219                 count += s.getAsSequence().size();
 220             }
 221         }
 222         return count;
 223     }
 224
 225     private static AsNumber getPeerAs(final List<Segments> segments) {
 226         if (segments.isEmpty()) {
 227             return new AsNumber(0L);
 228         }
 229         for (final Segments seg : segments) {
 230             if (seg.getAsSequence() != null && !seg.getAsSequence().isEmpty()) {
 231                 return segments.get(0).getAsSequence().get(0);
 232             }
 233         }
 234         return new AsNumber(0L);
 235     }
 236
 237     @VisibleForTesting
 238     public List<Segments> extractSegments(final UnkeyedListNode segments) {
 239         // list segments
 240         final List<Segments> extracted = new ArrayList<>();
 241         for (final UnkeyedListEntryNode segment : segments.getValue()) {
 242             final SegmentsBuilder sb = new SegmentsBuilder();
 243             // We are expecting that segment contains either as-sequence or as-set, so just one of them will be set, other would be null
 244             sb.setAsSequence(extractAsList(segment, this.ids.getAsSeq())).setAsSet(extractAsList(segment, this.ids.getAsSet()));
 245             extracted.add(sb.build());
 246         }
 247         return extracted;
 248     }
 249
 250     private List<AsNumber> extractAsList(final UnkeyedListEntryNode segment, final NodeIdentifier nid) {
 251         final List<AsNumber> ases = new ArrayList<>();
 252         final Optional<NormalizedNode<?, ?>> maybeAsList = NormalizedNodes.findNode(segment, nid);
 253         if (maybeAsList.isPresent()) {
 254             final LeafSetNode<?> list = (LeafSetNode<?>)maybeAsList.get();
 255             for (final LeafSetEntryNode<?> as : list.getValue())  {
 256                 ases.add(new AsNumber((Long)as.getValue()));
 257             }
 258             return ases;
 259         }
 260         return null;
 261     }
 262
 263     ContainerNode getAttributes() {
 264         return this.attributes;
 265     }
 266
 267     private ToStringHelper addToStringAttributes(final ToStringHelper toStringHelper) {
 268         toStringHelper.add("attributes", this.attributes);
 269         toStringHelper.add("localPref", this.localPref);
 270         toStringHelper.add("multiExitDisc", this.multiExitDisc);
 271         toStringHelper.add("origin", this.origin);
 272         toStringHelper.add("resolved", this.resolved);
 273         return toStringHelper;
 274     }
 275
 276     @Override
 277     public String toString() {
 278         return addToStringAttributes(MoreObjects.toStringHelper(this)).toString();
 279     }
 280
 281     @Override
 282     public int hashCode() {
 283         final int prime = 31;
 284         int result = 1;
 285         result = prime * result + this.attributes.hashCode();
 286         result = prime * result + ((this.localPref == null) ? 0 : this.localPref.hashCode());
 287         result = prime * result + ((this.multiExitDisc == null) ? 0 : this.multiExitDisc.hashCode());
 288         result = prime * result + ((this.origin == null) ? 0 : this.origin.hashCode());
 289         return result;
 290     }
 291
 292     @Override
 293     public boolean equals(final Object obj) {
 294         if (this == obj) {
 295             return true;
 296         }
 297         if (!(obj instanceof BestPathState)) {
 298             return false;
 299         }
 300         final BestPathState other = (BestPathState) obj;
 301         if (!this.attributes.equals(other.attributes)) {
 302             return false;
 303         }
 304         if (this.localPref == null) {
 305             if (other.localPref != null) {
 306                 return false;
 307             }
 308         } else if (!this.localPref.equals(other.localPref)) {
 309             return false;
 310         }
 311         if (this.multiExitDisc == null) {
 312             if (other.multiExitDisc != null) {
 313                 return false;
 314             }
 315         } else if (!this.multiExitDisc.equals(other.multiExitDisc)) {
 316             return false;
 317         }
 318         if (this.origin != other.origin) {
 319             return false;
 320         }
 321         return true;
 322     }
 323 }