*/
package org.opendaylight.protocol.bgp.mode.impl;
+import static java.util.Objects.requireNonNull;
+
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import com.google.common.collect.ImmutableList;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
-import java.util.concurrent.Callable;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import javax.annotation.concurrent.NotThreadSafe;
+import org.opendaylight.protocol.bgp.mode.BesthPathStateUtil;
import org.opendaylight.protocol.bgp.mode.api.BestPathState;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.AsNumber;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.path.attributes.attributes.AsPath;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.path.attributes.attributes.LocalPref;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.path.attributes.attributes.MultiExitDisc;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.path.attributes.attributes.Origin;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.path.attributes.attributes.as.path.Segments;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev130919.path.attributes.attributes.as.path.SegmentsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev171207.path.attributes.attributes.AsPath;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev171207.path.attributes.attributes.LocalPref;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev171207.path.attributes.attributes.MultiExitDisc;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev171207.path.attributes.attributes.Origin;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev171207.path.attributes.attributes.as.path.Segments;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev171207.path.attributes.attributes.as.path.SegmentsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.types.rev130919.BgpOrigin;
import org.opendaylight.yangtools.yang.common.QName;
import org.opendaylight.yangtools.yang.common.QNameModule;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.NodeIdentifier;
import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
import org.opendaylight.yangtools.yang.data.api.schema.ContainerNode;
-import org.opendaylight.yangtools.yang.data.api.schema.LeafNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetEntryNode;
import org.opendaylight.yangtools.yang.data.api.schema.LeafSetNode;
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
private final NodeIdentifier asSeqNid;
NamespaceSpecificIds(final QName namespace) {
- NodeIdentifier container = new NodeIdentifier(QName.create(namespace, AsPath.QNAME.getLocalName().intern()));
+ NodeIdentifier container = new NodeIdentifier(QName.create(namespace,
+ AsPath.QNAME.getLocalName().intern()));
NodeIdentifier leaf = new NodeIdentifier(QName.create(namespace, "segments").intern());
- this.asPath = ImmutableList.<PathArgument>of(container, leaf);
+ this.asPath = ImmutableList.of(container, leaf);
container = new NodeIdentifier(QName.create(namespace, LocalPref.QNAME.getLocalName()).intern());
leaf = new NodeIdentifier(QName.create(namespace, "pref").intern());
- this.locPref = ImmutableList.<PathArgument>of(container, leaf);
+ this.locPref = ImmutableList.of(container, leaf);
container = new NodeIdentifier(QName.create(namespace, MultiExitDisc.QNAME.getLocalName()).intern());
leaf = new NodeIdentifier(QName.create(namespace, "med").intern());
- this.med = ImmutableList.<PathArgument>of(container, leaf);
+ this.med = ImmutableList.of(container, leaf);
container = new NodeIdentifier(QName.create(namespace, Origin.QNAME.getLocalName()).intern());
leaf = new NodeIdentifier(QName.create(namespace, "value").intern());
- this.orig = ImmutableList.<PathArgument>of(container, leaf);
+ this.orig = ImmutableList.of(container, leaf);
this.asSetNid = new NodeIdentifier(QName.create(namespace, "as-set").intern());
this.asSeqNid = new NodeIdentifier(QName.create(namespace, "as-sequence").intern());
}
private static final Logger LOG = LoggerFactory.getLogger(BestPathStateImpl.class);
- private static final Cache<QNameModule, NamespaceSpecificIds> PATH_CACHE = CacheBuilder.newBuilder().weakKeys().weakValues().build();
+ private static final Cache<QNameModule, NamespaceSpecificIds> PATH_CACHE = CacheBuilder.newBuilder()
+ .weakKeys().weakValues().build();
private long peerAs = 0L;
private int asPathLength = 0;
public BestPathStateImpl(final ContainerNode attributes) {
final NamespaceSpecificIds col;
try {
- col = PATH_CACHE.get(attributes.getNodeType().getModule(), new Callable<NamespaceSpecificIds>() {
- @Override
- public NamespaceSpecificIds call() {
- return new NamespaceSpecificIds(attributes.getNodeType());
- }
- });
+ col = PATH_CACHE.get(attributes.getNodeType().getModule(),
+ () -> new NamespaceSpecificIds(attributes.getNodeType()));
} catch (final ExecutionException e) {
LOG.error("Error creating namespace-specific attributes collection.", e);
throw new IllegalStateException("Error creating namespace-specific attributes collection.", e);
}
- this.attributes = Preconditions.checkNotNull(attributes);
+ this.attributes = requireNonNull(attributes);
this.ids = col;
resolveValues();
}
private static BgpOrigin fromString(final String originStr) {
switch (originStr) {
- case "igp":
- return BgpOrigin.Igp;
- case "egp":
- return BgpOrigin.Egp;
- case "incomplete":
- return BgpOrigin.Incomplete;
- default:
- throw new IllegalArgumentException("Unhandled origin value " + originStr);
+ case "igp":
+ return BgpOrigin.Igp;
+ case "egp":
+ return BgpOrigin.Egp;
+ case "incomplete":
+ return BgpOrigin.Incomplete;
+ default:
+ throw new IllegalArgumentException("Unhandled origin value " + originStr);
}
}
return;
}
- final Optional<NormalizedNode<?, ?>> maybeLocalPref = NormalizedNodes.findNode(this.attributes, this.ids.getLocPref());
+ final Optional<NormalizedNode<?, ?>> maybeLocalPref
+ = NormalizedNodes.findNode(this.attributes, this.ids.getLocPref());
if (maybeLocalPref.isPresent()) {
- this.localPref = (Long) ((LeafNode<?>)maybeLocalPref.get()).getValue();
+ this.localPref = (Long) maybeLocalPref.get().getValue();
} else {
this.localPref = null;
}
- final Optional<NormalizedNode<?, ?>> maybeMultiExitDisc = NormalizedNodes.findNode(this.attributes, this.ids.getMed());
+ final Optional<NormalizedNode<?, ?>> maybeMultiExitDisc
+ = NormalizedNodes.findNode(this.attributes, this.ids.getMed());
if (maybeMultiExitDisc.isPresent()) {
- this.multiExitDisc = (Long) ((LeafNode<?>)maybeMultiExitDisc.get()).getValue();
+ this.multiExitDisc = (Long) maybeMultiExitDisc.get().getValue();
} else {
this.multiExitDisc = null;
}
- final Optional<NormalizedNode<?, ?>> maybeOrigin = NormalizedNodes.findNode(this.attributes, this.ids.getOrig());
+ final Optional<NormalizedNode<?, ?>> maybeOrigin
+ = NormalizedNodes.findNode(this.attributes, this.ids.getOrig());
if (maybeOrigin.isPresent()) {
- this.origin = fromString((String) ((LeafNode<?>)maybeOrigin.get()).getValue());
+ this.origin = fromString((String) maybeOrigin.get().getValue());
} else {
this.origin = null;
}
- final Optional<NormalizedNode<?, ?>> maybeSegments = NormalizedNodes.findNode(this.attributes, this.ids.getAsPath());
+ final Optional<NormalizedNode<?, ?>> maybeSegments
+ = NormalizedNodes.findNode(this.attributes, this.ids.getAsPath());
if (maybeSegments.isPresent()) {
final UnkeyedListNode segments = (UnkeyedListNode) maybeSegments.get();
final List<Segments> segs = extractSegments(segments);
if (!segs.isEmpty()) {
- this.peerAs = getPeerAs(segs).getValue();
+ this.peerAs = BesthPathStateUtil.getPeerAs(segs).getValue();
this.asPathLength = countAsPath(segs);
}
}
return count;
}
- private static AsNumber getPeerAs(final List<Segments> segments) {
- if (segments.isEmpty()) {
- return new AsNumber(0L);
- }
- for (final Segments seg : segments) {
- if (seg.getAsSequence() != null && !seg.getAsSequence().isEmpty()) {
- return segments.get(0).getAsSequence().get(0);
- }
- }
- return new AsNumber(0L);
- }
+
public List<Segments> extractSegments(final UnkeyedListNode segments) {
// list segments
final List<Segments> extracted = new ArrayList<>();
for (final UnkeyedListEntryNode segment : segments.getValue()) {
final SegmentsBuilder sb = new SegmentsBuilder();
- // We are expecting that segment contains either as-sequence or as-set, so just one of them will be set, other would be null
- sb.setAsSequence(extractAsList(segment, this.ids.getAsSeq())).setAsSet(extractAsList(segment, this.ids.getAsSet()));
+ // We are expecting that segment contains either as-sequence or as-set,
+ // so just one of them will be set, other would be null
+ sb.setAsSequence(extractAsList(segment, this.ids.getAsSeq()))
+ .setAsSet(extractAsList(segment, this.ids.getAsSet()));
extracted.add(sb.build());
}
return extracted;
}
- private List<AsNumber> extractAsList(final UnkeyedListEntryNode segment, final NodeIdentifier nid) {
+ private
static List<AsNumber> extractAsList(final UnkeyedListEntryNode segment, final NodeIdentifier nid) {
final List<AsNumber> ases = new ArrayList<>();
final Optional<NormalizedNode<?, ?>> maybeAsList = NormalizedNodes.findNode(segment, nid);
if (maybeAsList.isPresent()) {
final int prime = 31;
int result = 1;
result = prime * result + this.attributes.hashCode();
- result = prime * result + ((this.localPref == null) ? 0 : this.localPref.hashCode());
- result = prime * result + ((this.multiExitDisc == null) ? 0 : this.multiExitDisc.hashCode());
- result = prime * result + ((this.origin == null) ? 0 : this.origin.hashCode());
+ result = prime * result + (this.localPref == null ? 0 : this.localPref.hashCode());
+ result = prime * result + (this.multiExitDisc == null ? 0 : this.multiExitDisc.hashCode());
+ result = prime * result + (this.origin == null ? 0 : this.origin.hashCode());
return result;
}
Code Review / bgpcep.git / blobdiff