2 * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.
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
8 package org.opendaylight.protocol.bgp.mode.impl;
10 import static java.util.Objects.requireNonNull;
12 import com.google.common.base.MoreObjects;
13 import com.google.common.base.MoreObjects.ToStringHelper;
14 import com.google.common.cache.Cache;
15 import com.google.common.cache.CacheBuilder;
16 import com.google.common.collect.ImmutableList;
17 import java.util.ArrayList;
18 import java.util.Collection;
19 import java.util.List;
20 import java.util.Optional;
21 import java.util.concurrent.ExecutionException;
22 import javax.annotation.concurrent.NotThreadSafe;
23 import org.opendaylight.protocol.bgp.mode.BesthPathStateUtil;
24 import org.opendaylight.protocol.bgp.mode.api.BestPathState;
25 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.AsNumber;
26 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev171207.path.attributes.attributes.AsPath;
27 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev171207.path.attributes.attributes.LocalPref;
28 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev171207.path.attributes.attributes.MultiExitDisc;
29 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev171207.path.attributes.attributes.Origin;
30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev171207.path.attributes.attributes.as.path.Segments;
31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev171207.path.attributes.attributes.as.path.SegmentsBuilder;
32 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.BgpOrigin;
33 import org.opendaylight.yangtools.yang.common.QName;
34 import org.opendaylight.yangtools.yang.common.QNameModule;
35 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
36 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
37 import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
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;
48 public final class BestPathStateImpl implements 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;
57 NamespaceSpecificIds(final QName namespace) {
58 NodeIdentifier container = new NodeIdentifier(QName.create(namespace,
59 AsPath.QNAME.getLocalName().intern()));
60 NodeIdentifier leaf = new NodeIdentifier(QName.create(namespace, "segments").intern());
61 this.asPath = ImmutableList.of(container, leaf);
63 container = new NodeIdentifier(QName.create(namespace, LocalPref.QNAME.getLocalName()).intern());
64 leaf = new NodeIdentifier(QName.create(namespace, "pref").intern());
65 this.locPref = ImmutableList.of(container, leaf);
67 container = new NodeIdentifier(QName.create(namespace, MultiExitDisc.QNAME.getLocalName()).intern());
68 leaf = new NodeIdentifier(QName.create(namespace, "med").intern());
69 this.med = ImmutableList.of(container, leaf);
71 container = new NodeIdentifier(QName.create(namespace, Origin.QNAME.getLocalName()).intern());
72 leaf = new NodeIdentifier(QName.create(namespace, "value").intern());
73 this.orig = ImmutableList.of(container, leaf);
75 this.asSetNid = new NodeIdentifier(QName.create(namespace, "as-set").intern());
76 this.asSeqNid = new NodeIdentifier(QName.create(namespace, "as-sequence").intern());
79 Collection<PathArgument> getAsPath() {
83 Collection<PathArgument> getLocPref() {
87 Collection<PathArgument> getMed() {
91 Collection<PathArgument> getOrig() {
95 NodeIdentifier getAsSet() {
99 NodeIdentifier getAsSeq() {
100 return this.asSeqNid;
104 private static final Logger LOG = LoggerFactory.getLogger(BestPathStateImpl.class);
105 private static final Cache<QNameModule, NamespaceSpecificIds> PATH_CACHE = CacheBuilder.newBuilder()
106 .weakKeys().weakValues().build();
108 private long peerAs = 0L;
109 private int asPathLength = 0;
111 private final ContainerNode attributes;
112 private final NamespaceSpecificIds ids;
113 private Long localPref;
114 private Long multiExitDisc;
115 private BgpOrigin origin;
116 private boolean resolved;
118 public BestPathStateImpl(final ContainerNode attributes) {
119 final NamespaceSpecificIds col;
121 col = PATH_CACHE.get(attributes.getNodeType().getModule(),
122 () -> new NamespaceSpecificIds(attributes.getNodeType()));
123 } catch (final ExecutionException e) {
124 LOG.error("Error creating namespace-specific attributes collection.", e);
125 throw new IllegalStateException("Error creating namespace-specific attributes collection.", e);
128 this.attributes = requireNonNull(attributes);
133 private static BgpOrigin fromString(final String originStr) {
136 return BgpOrigin.Igp;
138 return BgpOrigin.Egp;
140 return BgpOrigin.Incomplete;
142 throw new IllegalArgumentException("Unhandled origin value " + originStr);
146 private void resolveValues() {
151 final Optional<NormalizedNode<?, ?>> maybeLocalPref
152 = NormalizedNodes.findNode(this.attributes, this.ids.getLocPref());
153 if (maybeLocalPref.isPresent()) {
154 this.localPref = (Long) maybeLocalPref.get().getValue();
156 this.localPref = null;
159 final Optional<NormalizedNode<?, ?>> maybeMultiExitDisc
160 = NormalizedNodes.findNode(this.attributes, this.ids.getMed());
161 if (maybeMultiExitDisc.isPresent()) {
162 this.multiExitDisc = (Long) maybeMultiExitDisc.get().getValue();
164 this.multiExitDisc = null;
167 final Optional<NormalizedNode<?, ?>> maybeOrigin
168 = NormalizedNodes.findNode(this.attributes, this.ids.getOrig());
169 if (maybeOrigin.isPresent()) {
170 this.origin = fromString((String) maybeOrigin.get().getValue());
175 final Optional<NormalizedNode<?, ?>> maybeSegments
176 = NormalizedNodes.findNode(this.attributes, this.ids.getAsPath());
177 if (maybeSegments.isPresent()) {
178 final UnkeyedListNode segments = (UnkeyedListNode) maybeSegments.get();
179 final List<Segments> segs = extractSegments(segments);
180 if (!segs.isEmpty()) {
181 this.peerAs = BesthPathStateUtil.getPeerAs(segs).getValue();
182 this.asPathLength = countAsPath(segs);
185 this.resolved = true;
189 public Long getLocalPref() {
191 return this.localPref;
195 public Long getMultiExitDisc() {
197 return this.multiExitDisc;
201 public BgpOrigin getOrigin() {
207 public Long getPeerAs() {
213 public int getAsPathLength() {
215 return this.asPathLength;
218 private static int countAsPath(final List<Segments> segments) {
219 // an AS_SET counts as 1, no matter how many ASs are in the set.
221 boolean setPresent = false;
222 for (final Segments s : segments) {
223 if (s.getAsSet() != null && !setPresent) {
226 } else if (s.getAsSequence() != null) {
227 count += s.getAsSequence().size();
235 public List<Segments> extractSegments(final UnkeyedListNode segments) {
237 final List<Segments> extracted = new ArrayList<>();
238 for (final UnkeyedListEntryNode segment : segments.getValue()) {
239 final SegmentsBuilder sb = new SegmentsBuilder();
240 // We are expecting that segment contains either as-sequence or as-set,
241 // so just one of them will be set, other would be null
242 sb.setAsSequence(extractAsList(segment, this.ids.getAsSeq()))
243 .setAsSet(extractAsList(segment, this.ids.getAsSet()));
244 extracted.add(sb.build());
249 private static List<AsNumber> extractAsList(final UnkeyedListEntryNode segment, final NodeIdentifier nid) {
250 final List<AsNumber> ases = new ArrayList<>();
251 final Optional<NormalizedNode<?, ?>> maybeAsList = NormalizedNodes.findNode(segment, nid);
252 if (maybeAsList.isPresent()) {
253 final LeafSetNode<?> list = (LeafSetNode<?>)maybeAsList.get();
254 for (final LeafSetEntryNode<?> as : list.getValue()) {
255 ases.add(new AsNumber((Long)as.getValue()));
263 public ContainerNode getAttributes() {
264 return this.attributes;
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;
277 public String toString() {
278 return addToStringAttributes(MoreObjects.toStringHelper(this)).toString();
282 public int hashCode() {
283 final int prime = 31;
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());
293 public boolean equals(final Object obj) {
297 if (!(obj instanceof BestPathStateImpl)) {
300 final BestPathStateImpl other = (BestPathStateImpl) obj;
301 if (!this.attributes.equals(other.attributes)) {
304 if (this.localPref == null) {
305 if (other.localPref != null) {
308 } else if (!this.localPref.equals(other.localPref)) {
311 if (this.multiExitDisc == null) {
312 if (other.multiExitDisc != null) {
315 } else if (!this.multiExitDisc.equals(other.multiExitDisc)) {
318 if (this.origin != other.origin) {