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.base.Optional;
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.ExecutionException;
22 import javax.annotation.concurrent.NotThreadSafe;
23 import org.opendaylight.protocol.bgp.mode.api.BestPathState;
24 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.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.LeafSetEntryNode;
38 import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
39 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
40 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNodes;
41 import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListEntryNode;
42 import org.opendaylight.yangtools.yang.data.api.schema.UnkeyedListNode;
43 import org.slf4j.Logger;
44 import org.slf4j.LoggerFactory;
47 public final class BestPathStateImpl implements BestPathState {
48 private static final class NamespaceSpecificIds {
49 private final Collection<PathArgument> asPath;
50 private final Collection<PathArgument> locPref;
51 private final Collection<PathArgument> med;
52 private final Collection<PathArgument> orig;
53 private final NodeIdentifier asSetNid;
54 private final NodeIdentifier asSeqNid;
56 NamespaceSpecificIds(final QName namespace) {
57 NodeIdentifier container = new NodeIdentifier(QName.create(namespace, AsPath.QNAME.getLocalName().intern()));
58 NodeIdentifier leaf = new NodeIdentifier(QName.create(namespace, "segments").intern());
59 this.asPath = ImmutableList.of(container, leaf);
61 container = new NodeIdentifier(QName.create(namespace, LocalPref.QNAME.getLocalName()).intern());
62 leaf = new NodeIdentifier(QName.create(namespace, "pref").intern());
63 this.locPref = ImmutableList.of(container, leaf);
65 container = new NodeIdentifier(QName.create(namespace, MultiExitDisc.QNAME.getLocalName()).intern());
66 leaf = new NodeIdentifier(QName.create(namespace, "med").intern());
67 this.med = ImmutableList.of(container, leaf);
69 container = new NodeIdentifier(QName.create(namespace, Origin.QNAME.getLocalName()).intern());
70 leaf = new NodeIdentifier(QName.create(namespace, "value").intern());
71 this.orig = ImmutableList.of(container, leaf);
73 this.asSetNid = new NodeIdentifier(QName.create(namespace, "as-set").intern());
74 this.asSeqNid = new NodeIdentifier(QName.create(namespace, "as-sequence").intern());
77 Collection<PathArgument> getAsPath() {
81 Collection<PathArgument> getLocPref() {
85 Collection<PathArgument> getMed() {
89 Collection<PathArgument> getOrig() {
93 NodeIdentifier getAsSet() {
97 NodeIdentifier getAsSeq() {
102 private static final Logger LOG = LoggerFactory.getLogger(BestPathStateImpl.class);
103 private static final Cache<QNameModule, NamespaceSpecificIds> PATH_CACHE = CacheBuilder.newBuilder().weakKeys().weakValues().build();
105 private long peerAs = 0L;
106 private int asPathLength = 0;
108 private final ContainerNode attributes;
109 private final NamespaceSpecificIds ids;
110 private Long localPref;
111 private Long multiExitDisc;
112 private BgpOrigin origin;
113 private boolean resolved;
115 public BestPathStateImpl(final ContainerNode attributes) {
116 final NamespaceSpecificIds col;
118 col = PATH_CACHE.get(attributes.getNodeType().getModule(), () -> new NamespaceSpecificIds(attributes.getNodeType()));
119 } catch (final ExecutionException e) {
120 LOG.error("Error creating namespace-specific attributes collection.", e);
121 throw new IllegalStateException("Error creating namespace-specific attributes collection.", e);
124 this.attributes = requireNonNull(attributes);
129 private static BgpOrigin fromString(final String originStr) {
132 return BgpOrigin.Igp;
134 return BgpOrigin.Egp;
136 return BgpOrigin.Incomplete;
138 throw new IllegalArgumentException("Unhandled origin value " + originStr);
142 private void resolveValues() {
147 final Optional<NormalizedNode<?, ?>> maybeLocalPref = NormalizedNodes.findNode(this.attributes, this.ids.getLocPref());
148 if (maybeLocalPref.isPresent()) {
149 this.localPref = (Long) maybeLocalPref.get().getValue();
151 this.localPref = null;
154 final Optional<NormalizedNode<?, ?>> maybeMultiExitDisc = NormalizedNodes.findNode(this.attributes, this.ids.getMed());
155 if (maybeMultiExitDisc.isPresent()) {
156 this.multiExitDisc = (Long) maybeMultiExitDisc.get().getValue();
158 this.multiExitDisc = null;
161 final Optional<NormalizedNode<?, ?>> maybeOrigin = NormalizedNodes.findNode(this.attributes, this.ids.getOrig());
162 if (maybeOrigin.isPresent()) {
163 this.origin = fromString((String) maybeOrigin.get().getValue());
168 final Optional<NormalizedNode<?, ?>> maybeSegments = NormalizedNodes.findNode(this.attributes, this.ids.getAsPath());
169 if (maybeSegments.isPresent()) {
170 final UnkeyedListNode segments = (UnkeyedListNode) maybeSegments.get();
171 final List<Segments> segs = extractSegments(segments);
172 if (!segs.isEmpty()) {
173 this.peerAs = getPeerAs(segs).getValue();
174 this.asPathLength = countAsPath(segs);
177 this.resolved = true;
181 public Long getLocalPref() {
183 return this.localPref;
187 public Long getMultiExitDisc() {
189 return this.multiExitDisc;
193 public BgpOrigin getOrigin() {
199 public Long getPeerAs() {
205 public int getAsPathLength() {
207 return this.asPathLength;
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.
213 boolean setPresent = false;
214 for (final Segments s : segments) {
215 if (s.getAsSet() != null && !setPresent) {
218 } else if (s.getAsSequence() != null) {
219 count += s.getAsSequence().size();
225 private static AsNumber getPeerAs(final List<Segments> segments) {
226 if (segments.isEmpty()) {
227 return new AsNumber(0L);
229 for (final Segments seg : segments) {
230 if (seg.getAsSequence() != null && !seg.getAsSequence().isEmpty()) {
231 return segments.get(0).getAsSequence().get(0);
234 return new AsNumber(0L);
237 public List<Segments> extractSegments(final UnkeyedListNode segments) {
239 final List<Segments> extracted = new ArrayList<>();
240 for (final UnkeyedListEntryNode segment : segments.getValue()) {
241 final SegmentsBuilder sb = new SegmentsBuilder();
242 // We are expecting that segment contains either as-sequence or as-set, so just one of them will be set, other would be null
243 sb.setAsSequence(extractAsList(segment, this.ids.getAsSeq())).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) {