.DS_STORE
.metadata
.checkstyle
+.factorypath
</dependency>
</dependencies>
- <build>
- <plugins>
- <plugin>
- <groupId>org.apache.felix</groupId>
- <artifactId>maven-bundle-plugin</artifactId>
- <extensions>true</extensions>
- <configuration>
- <instructions>
- <!-- This bundle works with Karaf 3 and 4.0, see https://wiki.opendaylight.org/view/Karaf_4_migration#Karaf_CLI_commands -->
- <Import-Package>
- org.apache.karaf.shell.commands;version="[3.0.0,4.1)",
- org.apache.karaf.shell.console;version="[3.0.0,4.1)",
- org.apache.karaf.shell.table;version="[3.0.0,4.1)",
- *
- </Import-Package>
- </instructions>
- </configuration>
- </plugin>
- </plugins>
- </build>
-
<scm>
<connection>scm:git:ssh://git.opendaylight.org:29418/bgpcep.git</connection>
<developerConnection>scm:git:ssh://git.opendaylight.org:29418/bgpcep.git</developerConnection>
public static RouteDistinguisher extractRouteDistinguisher(final DataContainerNode<?> route,
final NodeIdentifier rdNid) {
- final NormalizedNode<?, ?> rdNode = NormalizedNodes.findNode(route, rdNid).orNull();
+ final NormalizedNode<?, ?> rdNode = NormalizedNodes.findNode(route, rdNid).orElse(null);
if (rdNode != null) {
return parseRouteDistinguisher(rdNode.getValue());
}
*/
package org.opendaylight.protocol.bgp.evpn.impl;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.ImmutableSet;
import io.netty.buffer.ByteBuf;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
public static final String RD_MODEL = "1.2.3.4:258";
public static final RouteDistinguisher RD = RouteDistinguisherBuilder.getDefaultInstance(RD_MODEL);
+ private EvpnTestUtil() {
+ throw new UnsupportedOperationException();
+ }
+
public static DataContainerNodeAttrBuilder<NodeIdentifier, ContainerNode> createContBuilder(
final NodeIdentifier nid) {
return ImmutableContainerNodeSchemaAwareBuilder.create().withNodeIdentifier(nid);
static final IpAddress IP_ADDRESS = new IpAddress(new Ipv4Address("1.1.1.1"));
private static final Short NO_SUPPORTED_OPAQUE = 200;
+ private PMSITunnelAttributeHandlerTestUtil() {
+ throw new UnsupportedOperationException();
+ }
+
static class MockTunnelIdentifier implements TunnelIdentifier {
@Override
public Class<? extends DataContainer> getImplementedInterface() {
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Joiner;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import static java.util.Objects.requireNonNull;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import java.util.Collection;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.protocol.bgp.parser.spi.PathIdUtil;
*/
package org.opendaylight.protocol.bgp.flowspec.ipv4;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import java.util.Set;
import org.opendaylight.protocol.bgp.flowspec.AbstractFlowspecNlriParser;
import org.opendaylight.protocol.bgp.flowspec.handlers.NumericOneByteOperandParser;
*/
package org.opendaylight.protocol.bgp.flowspec.ipv6;
-import com.google.common.base.Optional;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import java.util.Set;
import org.opendaylight.protocol.bgp.flowspec.AbstractFlowspecNlriParser;
import org.opendaylight.protocol.bgp.flowspec.handlers.NumericOneByteOperandParser;
*/
package org.opendaylight.protocol.bgp.inet;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.ImmutableSet;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.protocol.bgp.parser.spi.PathIdUtil;
protected AbstractIPRibSupport(final Class<? extends DataObject> prefixClass,
final Class<? extends AddressFamily> addressFamilyClass,
- final Class<? extends Routes> cazeClass,
+ final Class<? extends Routes> cazeClass,
final Class<? extends DataObject> containerClass, final Class<? extends Route> listClass,
- final QName destinationQname, final QName prefixesQname) {
+ final QName destinationQname, final QName prefixesQname) {
super(cazeClass, containerClass, listClass, addressFamilyClass,
UnicastSubsequentAddressFamily.class, "prefix", destinationQname);
this.prefixNid = new NodeIdentifier(routeKeyQName());
*/
package org.opendaylight.protocol.bgp.l3vpn;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.ImmutableSet;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import org.opendaylight.bgp.concepts.RouteDistinguisherUtil;
package org.opendaylight.protocol.bgp.labeled.unicast;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.ImmutableSet;
import io.netty.buffer.ByteBuf;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.stream.Collectors;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
import org.opendaylight.protocol.bgp.parser.spi.PathIdUtil;
*/
package org.opendaylight.protocol.bgp.linkstate.impl;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.ImmutableSet;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import java.util.Collection;
import java.util.List;
+import java.util.Optional;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
package org.opendaylight.protocol.bgp.linkstate.impl.nlri;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import io.netty.buffer.ByteBuf;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import org.opendaylight.protocol.bgp.linkstate.spi.AbstractTeLspNlriCodec;
import org.opendaylight.protocol.bgp.linkstate.spi.pojo.SimpleNlriTypeRegistry;
import org.opendaylight.protocol.bgp.parser.BGPParsingException;
final Attributes1 pathAttributes1 = pathAttributes.getAugmentation(Attributes1.class);
final Attributes2 pathAttributes2 = pathAttributes.getAugmentation(Attributes2.class);
if (pathAttributes1 != null) {
- serializeAdvertisedRoutes((pathAttributes1.getMpReachNlri()).getAdvertizedRoutes(), byteAggregator);
+ serializeAdvertisedRoutes(pathAttributes1.getMpReachNlri().getAdvertizedRoutes(), byteAggregator);
} else if (pathAttributes2 != null) {
serializeWithDrawnRoutes(pathAttributes2.getMpUnreachNlri().getWithdrawnRoutes(), byteAggregator);
}
package org.opendaylight.protocol.bgp.linkstate.impl.nlri;
import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Optional;
import io.netty.buffer.ByteBuf;
+import java.util.Optional;
import org.opendaylight.protocol.bgp.linkstate.impl.tlvs.AreaIdTlvParser;
import org.opendaylight.protocol.bgp.linkstate.impl.tlvs.AsNumTlvParser;
import org.opendaylight.protocol.bgp.linkstate.impl.tlvs.BgpRouterIdTlvParser;
*/
package org.opendaylight.protocol.bgp.linkstate.impl.tlvs;
-import com.google.common.base.Optional;
import io.netty.buffer.ByteBuf;
+import java.util.Optional;
import org.opendaylight.protocol.bgp.linkstate.spi.LinkstateTlvParser;
import org.opendaylight.protocol.util.ByteBufWriteUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.linkstate.rev171207.OspfRouteType;
package org.opendaylight.protocol.bgp.parser.spi;
-import com.google.common.base.Optional;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableMap;
import io.netty.buffer.ByteBuf;
+import java.util.Optional;
import org.opendaylight.protocol.util.ByteBufWriteUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev171207.PathId;
import org.opendaylight.yangtools.yang.common.QName;
* @return The path identifier from data change
*/
public static Long extractPathId(final NormalizedNode<?, ?> data, final NodeIdentifier pathNii) {
- final NormalizedNode<?, ?> pathId = NormalizedNodes.findNode(data, pathNii).orNull();
- if (pathId == null) {
- return null;
- }
- return (Long) pathId.getValue();
+ return (Long) NormalizedNodes.findNode(data, pathNii).map(NormalizedNode::getValue).orElse(null);
}
/**
* @return Route Key Nid
*/
public static NodeIdentifierWithPredicates createNidKey(final long pathId, final PathArgument routeId,
- final QName routeQname, final QName pathidQname, final QName routeKeyQname) {
+ final QName routeQname,
+ final QName pathidQname, final QName routeKeyQname) {
return createNodeIdentifierWithPredicates(routeQname, pathidQname, pathId, routeKeyQname,
getObjectKey(routeId, routeKeyQname));
}
* @return key
*/
public static Object getObjectKey(final PathArgument routeId, final QName routeKeyQname) {
- return (((NodeIdentifierWithPredicates) routeId).getKeyValues()).get(routeKeyQname);
+ return ((NodeIdentifierWithPredicates) routeId).getKeyValues().get(routeKeyQname);
}
- public static NodeIdentifierWithPredicates createNodeIdentifierWithPredicates(final QName routeQname,
- final QName pathidQname, final Object pathId, final QName routeKeyQname, final Object keyObject) {
+ public static NodeIdentifierWithPredicates createNodeIdentifierWithPredicates(final QName routeQname, final QName pathidQname, final Object pathId,
+ final QName routeKeyQname, final Object keyObject) {
final ImmutableMap<QName, Object> keyValues = ImmutableMap.of(pathidQname, pathId, routeKeyQname, keyObject);
return new NodeIdentifierWithPredicates(routeQname, keyValues);
}
* @param pathIdQname path Id Qname
* @param routeKeyValue route key value
* @param maybePathIdLeaf path id container, it might me supported or not, in that case default 0 value will
- * be assigned
+ * be
+ * assigned
* @return Route Key Nid
*/
public static NodeIdentifierWithPredicates createNidKey(final QName routeQname, final QName routeKeyQname,
final QName pathIdQname, final Object routeKeyValue,
final Optional<DataContainerChild<? extends PathArgument, ?>> maybePathIdLeaf) {
// FIXME: a cache here would mean we instantiate the same identifier for each route making comparison quicker.
- final Object pathId = maybePathIdLeaf.isPresent() ? (maybePathIdLeaf.get()).getValue() : NON_PATH_ID;
+ final Object pathId = maybePathIdLeaf.isPresent() ? maybePathIdLeaf.get().getValue() : NON_PATH_ID;
return createNodeIdentifierWithPredicates(routeQname, pathIdQname, pathId, routeKeyQname, routeKeyValue);
}
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev171207.path.attributes.attributes.as.path.Segments;
public final class BesthPathStateUtil {
- BesthPathStateUtil() {
+ private BesthPathStateUtil() {
throw new UnsupportedOperationException();
}
import com.google.common.base.MoreObjects;
import com.google.common.base.MoreObjects.ToStringHelper;
-import com.google.common.base.Optional;
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.Optional;
import java.util.concurrent.ExecutionException;
import javax.annotation.concurrent.NotThreadSafe;
import org.opendaylight.protocol.bgp.mode.BesthPathStateUtil;
final NormalizedNode<?, ?> data) {
LOG.trace("Find {} in {}", attributesIdentifier, data);
final ContainerNode advertisedAttrs
- = (ContainerNode) NormalizedNodes.findNode(data, attributesIdentifier).orNull();
+ = (ContainerNode) NormalizedNodes.findNode(data, attributesIdentifier).orElse(null);
return addRoute(key, advertisedAttrs);
}
final NodeIdentifier attributesIdentifier, final NormalizedNode<?, ?> data) {
LOG.trace("Find {} in {}", attributesIdentifier, data);
final ContainerNode advertisedAttrs = (ContainerNode) NormalizedNodes
- .findNode(data, attributesIdentifier).orNull();
+ .findNode(data, attributesIdentifier).orElse(null);
int offset = this.offsets.offsetOf(routerId);
if (offset < 0) {
final OffsetMap newOffsets = this.offsets.with(routerId);
package org.opendaylight.protocol.bgp.mode.spi;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableList;
import com.google.common.primitives.UnsignedInteger;
import java.util.Collection;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.protocol.bgp.mode.api.BestPathState;
import org.opendaylight.protocol.bgp.rib.spi.RouterIds;
final BGPDispatcher bgpDispatcher) {
this.bgpDispatcher = requireNonNull(bgpDispatcher);
this.address = getAddress(requireNonNull(bindingAddress), requireNonNull(portNumber));
- if (!PlatformDependent.isWindows() && !PlatformDependent.isRoot()
+ if (!PlatformDependent.isWindows() && !PlatformDependent.maybeSuperUser()
&& portNumber.getValue() < PRIVILEGED_PORTS) {
throw new AccessControlException("Unable to bind port " + portNumber.getValue()
+ " while running as non-root user.");
}
}
- private static InetSocketAddress getAddress(final IpAddress ipAddress, final PortNumber portNumber) {
- final InetAddress inetAddr;
- try {
- inetAddr = InetAddress.getByName(ipAddress.getIpv4Address() != null
- ? ipAddress.getIpv4Address().getValue() : ipAddress.getIpv6Address().getValue());
- } catch (final UnknownHostException e) {
- throw new IllegalArgumentException("Illegal binding address " + ipAddress, e);
- }
- return new InetSocketAddress(inetAddr, portNumber.getValue());
- }
-
public void start() {
LOG.debug("Instantiating BGP Peer Acceptor : {}", this.address);
// Validate future success
this.futureChannel.addListener(future -> {
Preconditions.checkArgument(future.isSuccess(), "Unable to start bgp server on %s",
- this.address, future.cause());
+ this.address, future.cause());
final Channel channel = this.futureChannel.channel();
if (Epoll.isAvailable()) {
this.listenerRegistration = this.bgpDispatcher.getBGPPeerRegistry().registerPeerRegisterListener(
- new BGPPeerAcceptorImpl.PeerRegistryListenerImpl(channel.config()));
+ new BGPPeerAcceptorImpl.PeerRegistryListenerImpl(channel.config()));
}
});
}
+ private static InetSocketAddress getAddress(final IpAddress ipAddress, final PortNumber portNumber) {
+ final InetAddress inetAddr;
+ try {
+ inetAddr = InetAddress.getByName(ipAddress.getIpv4Address() != null
+ ? ipAddress.getIpv4Address().getValue() : ipAddress.getIpv6Address().getValue());
+ } catch (final UnknownHostException e) {
+ throw new IllegalArgumentException("Illegal binding address " + ipAddress, e);
+ }
+ return new InetSocketAddress(inetAddr, portNumber.getValue());
+ }
+
/**
* This closes the acceptor and no new bgp connections will be accepted
* Connections already established will be preserved.
import static java.util.Objects.requireNonNull;
-import com.google.common.base.Optional;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.atomic.LongAdder;
import java.util.stream.Collectors;
import javax.annotation.Nonnull;
LOG.debug("AdjRibOut parsing route {}", NormalizedNodes.toStringTree(route));
}
final ContainerNode advertisedAttrs = (ContainerNode) NormalizedNodes.findNode(route,
- this.support.routeAttributesIdentifier()).orNull();
+ this.support.routeAttributesIdentifier()).orElse(null);
return this.codecs.deserializeAttributes(advertisedAttrs);
}
*/
package org.opendaylight.protocol.bgp.rib.impl;
-import com.google.common.base.Optional;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.LoadingCache;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import java.util.Iterator;
+import java.util.Optional;
import org.opendaylight.protocol.util.Values;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev130715.Ipv4Address;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.bgp.message.rev171207.path.attributes.attributes.AsPath;
import static java.util.Objects.requireNonNull;
-import com.google.common.base.Optional;
import com.google.common.base.Verify;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import java.util.Collection;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.atomic.LongAdder;
import javax.annotation.Nonnull;
AdjInTracker(final DOMDataTreeChangeService service, final RIBSupportContextRegistry registry,
final DOMTransactionChain chain, final YangInstanceIdentifier peerIId,
- @Nonnull Set<TablesKey> tables) {
+ @Nonnull
final Set<TablesKey> tables) {
this.registry = requireNonNull(registry);
this.chain = requireNonNull(chain);
this.peerIId = requireNonNull(peerIId);
tx.put(LogicalDatastoreType.OPERATIONAL, routeId, route.getDataAfter().get());
CountersUtil.increment(this.prefixesReceived.get(tablesKey), tablesKey);
// Lookup per-table attributes from RIBSupport
- final ContainerNode advertisedAttrs = (ContainerNode) NormalizedNodes.findNode(route.getDataAfter(), ribSupport.routeAttributesIdentifier()).orNull();
+ final ContainerNode advertisedAttrs = (ContainerNode) NormalizedNodes.findNode(route.getDataAfter(), ribSupport.routeAttributesIdentifier()).orElse(null);
final ContainerNode effectiveAttrs;
if (advertisedAttrs != null) {
@Nonnull final ImportPolicyPeerTracker importPolicyPeerTracker,
@Nonnull final RIBSupportContextRegistry registry,
final PeerRole peerRole,
- @Nonnull Set<TablesKey> tables) {
+ @Nonnull
final Set<TablesKey> tables) {
return new EffectiveRibInWriter(service, chain, peerIId, importPolicyPeerTracker, registry, peerRole, tables);
}
final ImportPolicyPeerTracker importPolicyPeerTracker,
final RIBSupportContextRegistry registry,
final PeerRole peerRole,
- @Nonnull Set<TablesKey> tables) {
+ @Nonnull
final Set<TablesKey> tables) {
importPolicyPeerTracker.peerRoleChanged(peerIId, peerRole);
this.importPolicy = importPolicyPeerTracker.policyFor(IdentifierUtils.peerId((NodeIdentifierWithPredicates) peerIId.getLastPathArgument()));
this.adjInTracker = new AdjInTracker(service, registry, chain, peerIId, tables);
import static java.util.Objects.requireNonNull;
-import com.google.common.base.Optional;
import com.google.common.primitives.UnsignedInteger;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
+import java.util.Optional;
import java.util.Set;
import java.util.concurrent.atomic.LongAdder;
import javax.annotation.Nonnull;
final Map<RouteUpdateKey, RouteEntry> routes) {
for (final DataTreeCandidateNode child : table.getChildNodes()) {
LOG.debug("Modification type {}", child.getModificationType());
- if ((Attributes.QNAME).equals(child.getIdentifier().getNodeType())) {
+ if (Attributes.QNAME.equals(child.getIdentifier().getNodeType())) {
if (child.getDataAfter().isPresent()) {
// putting uptodate attribute in
LOG.trace("Uptodate found for {}", child.getDataAfter());
import org.opendaylight.yangtools.yang.binding.util.BindingReflections;
import org.opendaylight.yangtools.yang.model.api.SchemaContext;
-class AbstractAddPathTest extends AbstractConcurrentDataBrokerTest {
+public abstract class AbstractAddPathTest extends AbstractConcurrentDataBrokerTest {
private static final int RETRY_TIMER = 10;
static final String RIB_ID = "127.0.0.1";
static final BgpId BGP_ID = new BgpId(RIB_ID);
final DataTreeCandidateNode child = mock(DataTreeCandidateNode.class);
doReturn(createIdentifier(p)).when(child).getIdentifier();
- doReturn(Optional.of(b.build())).when(child).getDataAfter();
+ doReturn(java.util.Optional.of(b.build())).when(child).getDataAfter();
doReturn(type).when(child).getModificationType();
children.add(child);
}
Mockito.doReturn(mock(GeneratedClassLoadingStrategy.class)).when(this.extension).getClassLoadingStrategy();
Mockito.doReturn(this.ribSupport).when(this.extension).getRIBSupport(any(TablesKey.class));
- final NodeIdentifier nii = new NodeIdentifier(QName.create("test").intern());
+ final NodeIdentifier nii = new NodeIdentifier(QName.create("", "test").intern());
Mockito.doReturn(nii).when(this.ribSupport).routeAttributesIdentifier();
Mockito.doReturn(ImmutableSet.of()).when(this.ribSupport).cacheableAttributeObjects();
final ChoiceNode choiceNode = mock(ChoiceNode.class);
Mockito.doReturn(choiceNode).when(this.ribSupport).emptyRoutes();
Mockito.doReturn(nii).when(choiceNode).getIdentifier();
- Mockito.doReturn(QName.create("test").intern()).when(choiceNode).getNodeType();
+ Mockito.doReturn(QName.create("", "test").intern()).when(choiceNode).getNodeType();
Mockito.doReturn(this.domTx).when(this.domDataBroker).createTransactionChain(any());
final DOMDataTreeChangeService dOMDataTreeChangeService = mock(DOMDataTreeChangeService.class);
Mockito.doReturn(Collections.singletonMap(DOMDataTreeChangeService.class, dOMDataTreeChangeService))
import static java.util.Objects.requireNonNull;
import com.google.common.annotations.Beta;
-import com.google.common.base.Optional;
import java.util.Collection;
import java.util.Collections;
+import java.util.Optional;
import javax.annotation.Nonnull;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
private static ContainerNode getDestination(final DataContainerChild<? extends PathArgument, ?> routes,
final NodeIdentifier destinationId) {
if (routes instanceof ContainerNode) {
- final Optional<DataContainerChild<? extends PathArgument, ?>> maybeDestination =
+ final java.util.Optional<DataContainerChild<? extends PathArgument, ?>> maybeDestination =
((ContainerNode) routes).getChild(DESTINATION_TYPE);
if (maybeDestination.isPresent()) {
final DataContainerChild<? extends PathArgument, ?> destination = maybeDestination.get();
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doReturn;
-import com.google.common.base.Optional;
import com.google.common.collect.ImmutableMap;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
+import java.util.Optional;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
.withNodeIdentifier(new NodeIdentifier(QName.create(Ipv4Routes.QNAME, Attributes.QNAME
.getLocalName().intern()))).build();
final ContainerNode destination = Mockito.mock(ContainerNode.class);
- final ContainerNode route = Mockito.mock(ContainerNode.class);
- final Optional<?> optional = Mockito.mock(Optional.class);
- final Optional<?> destinationOptional = Mockito.mock(Optional.class);
- final Optional<?> destinationsOptional = Mockito.mock(Optional.class);
final ChoiceNode destinations = Mockito.mock(ChoiceNode.class);
+ final ContainerNode route = Mockito.mock(ContainerNode.class);
+ final Optional<?> optional = Optional.of(destination);
+ final Optional<?> destinationOptional = Optional.of(destinations);
+ final Optional<?> destinationsOptional = Optional.of(route);
doReturn(optional).when(this.nlri).getChild(new NodeIdentifier(WithdrawnRoutes.QNAME));
doReturn(optional).when(this.nlri).getChild(new NodeIdentifier(AdvertizedRoutes.QNAME));
- doReturn(true).when(optional).isPresent();
- doReturn(destination).when(optional).get();
doReturn(destinationOptional).when(destination).getChild(new NodeIdentifier(DestinationType.QNAME));
- doReturn(true).when(destinationOptional).isPresent();
- doReturn(destinations).when(destinationOptional).get();
doReturn(destinationsOptional).when(destinations).getChild(new NodeIdentifier(Ipv4Prefixes.QNAME));
- doReturn(true).when(destinationsOptional).isPresent();
- doReturn(route).when(destinationsOptional).get();
doReturn(emptyCollection).when(route).getValue();
doAnswer(invocation -> {
}
@Override
- public final synchronized void onTransactionChainFailed(final TransactionChain<?, ?> chain,
+ public final synchronized void onTransactionChainFailed(final TransactionChain<?, ?> transactionChain,
final AsyncTransaction<?, ?> transaction, final Throwable cause) {
LOG.error("Topology builder for {} failed in transaction {}.", getInstanceIdentifier(),
transaction != null ? transaction.getIdentifier() : null, cause);
}
@Override
- public final void onTransactionChainSuccessful(final TransactionChain<?, ?> chain) {
+ public final void onTransactionChainSuccessful(final TransactionChain<?, ?> transactionChain) {
LOG.info("Topology builder for {} shut down", getInstanceIdentifier());
}
}
LOG.debug("Node {} is unadvertized", this.nb.getNodeId());
}
- private void advertized(final NodeBuilder nb, final IgpNodeAttributesBuilder inab) {
- this.nb = requireNonNull(nb);
- this.inab = requireNonNull(inab);
+ private void advertized(final NodeBuilder nodeBuilder, final IgpNodeAttributesBuilder igpNodeAttBuilder) {
+ this.nb = requireNonNull(nodeBuilder);
+ this.inab = requireNonNull(igpNodeAttBuilder);
this.advertized = true;
- LOG.debug("Node {} is advertized", nb.getNodeId());
+ LOG.debug("Node {} is advertized", nodeBuilder.getNodeId());
}
private NodeId getNodeId() {
return SERVICE_GROUP_IDENTIFIER;
}
- private void connectMonitoredRouters(final BmpDispatcher dispatcher) {
+ private void connectMonitoredRouters(final BmpDispatcher pdispatcher) {
if (this.monitoredRouters != null) {
for (final MonitoredRouter mr : this.monitoredRouters) {
if (mr.isActive()) {
final KeyMapping ret;
final Rfc2385Key rfc2385KeyPassword = mr.getPassword();
ret = KeyMapping.getKeyMapping(addr, rfc2385KeyPassword.getValue());
- dispatcher.createClient(Ipv4Util.toInetSocketAddress(mr.getAddress(), mr.getPort()),
+ pdispatcher.createClient(Ipv4Util.toInetSocketAddress(mr.getAddress(), mr.getPort()),
this.sessionManager, ret);
}
}
}
@Override
- public synchronized void onSessionUp(final BmpSession session) {
- this.session = session;
+ public synchronized void onSessionUp(final BmpSession psession) {
+ this.session = psession;
this.routerIp = InetAddresses.toAddrString(this.session.getRemoteAddress());
this.routerId = new RouterId(Ipv4Util.getIpAddress(this.session.getRemoteAddress()));
// check if this session is redundant
LOG.info("BMP session {} successfully established.", this.channel);
final InetSocketAddress localAddress = (InetSocketAddress) this.channel.localAddress();
this.remoteAddress = (InetSocketAddress) this.channel.remoteAddress();
- advertizePeers(this.channel, localAddress);
+ advertizePeers(localAddress);
}
- private void advertizePeers(final Channel channel, final InetSocketAddress localAddress) {
+ private void advertizePeers(final InetSocketAddress localAddress) {
channel.writeAndFlush(BmpMockUtil.createInitiation());
Ipv4Address peerAddress = PEER_ADDRESS;
for (int i = 0; i < this.peersCount; i++) {
public synchronized void loadConfiguration(final NormalizedNode<?, ?> dto) {
final ContainerNode bmpMonitorsConfigsContainer = (ContainerNode) dto;
final MapNode monitorsList = (MapNode) bmpMonitorsConfigsContainer.getChild(
- this.bmpMonitorsYii.getLastPathArgument()).orNull();
+ this.bmpMonitorsYii.getLastPathArgument()).orElse(null);
if (monitorsList == null) {
return;
}
}
}
- private synchronized void handleChanges(final WatchService watchService) {
+ private synchronized void handleChanges(final WatchService watch) {
final WatchKey key;
try {
- key = watchService.take();
+ key = watch.take();
} catch (final InterruptedException | ClosedWatchServiceException e) {
if (!ConfigLoaderImpl.this.closed) {
LOG.warn(INTERRUPTED, e);
this.eventList.add(this.watchEvent);
}
-
@After
public final void tearDown() throws Exception {
((ConfigLoaderImpl) this.configLoader).close();
}
}
- private void createPCC(@Nonnull final InetSocketAddress localAddress, @Nonnull final PCCTunnelManager tunnelManager,
- final BigInteger initialDBVersion) throws InterruptedException, ExecutionException {
+ private void createPCC(@Nonnull final InetSocketAddress plocalAddress,
+ final PCCTunnelManager tunnelManager, final BigInteger initialDBVersion)
+ throws InterruptedException, ExecutionException {
final PCEPSessionNegotiatorFactory<PCEPSessionImpl> snf = getSessionNegotiatorFactory();
for (final InetSocketAddress pceAddress : this.remoteAddress) {
this.pccDispatcher.createClient(pceAddress, this.reconnectTime, () -> new PCCSessionListener(
- this.remoteAddress.indexOf(pceAddress), tunnelManager, this.pcError), snf,
- KeyMapping.getKeyMapping(pceAddress.getAddress(), this.password), localAddress, initialDBVersion);
+ this.remoteAddress.indexOf(pceAddress), tunnelManager, this.pcError), snf,
+ KeyMapping.getKeyMapping(pceAddress.getAddress(), this.password), plocalAddress, initialDBVersion);
}
}
}
}
- public void setPCCDispatcher(final PCCDispatcherImpl pccDispatcher) {
- this.pccDispatcher = pccDispatcher;
+ public void setPCCDispatcher(final PCCDispatcherImpl dispatcher) {
+ this.pccDispatcher = dispatcher;
}
}
}
@Override
- public void onMessage(final PCEPSession session, final Message message) {
+ public void onMessage(final PCEPSession psession, final Message message) {
LOG.trace("Received message: {}", message);
if (this.errorMode) {
//random error message
- session.sendMessage(createErrorMessage(message));
+ psession.sendMessage(createErrorMessage(message));
return;
}
if (message instanceof Pcupd) {
}
@Override
- public void onSessionUp(final PCEPSession session) {
+ public void onSessionUp(final PCEPSession psession) {
LOG.debug("Session up.");
- this.session = session;
+ this.session = psession;
this.tunnelManager.onSessionUp(this);
}
@Override
@SuppressWarnings("checkstyle:IllegalCatch")
- public void onSessionDown(final PCEPSession session, final Exception exception) {
+ public void onSessionDown(final PCEPSession psession, final Exception exception) {
LOG.info("Session down with cause : {} or exception: {}", exception.getCause(), exception, exception);
this.tunnelManager.onSessionDown(this);
try {
- session.close();
+ psession.close();
} catch (Exception ie) {
LOG.warn("Error closing session", ie);
}
}
@Override
- public void onSessionTerminated(final PCEPSession session, final PCEPTerminationReason cause) {
+ public void onSessionTerminated(final PCEPSession psession, final PCEPTerminationReason cause) {
LOG.info("Session terminated. Cause : {}", cause.toString());
}
@Override
public Tlvs localSessionCharacteristics() {
- return this.session.localSessionCharacteristics();
+ return this.session.getLocalTlvs();
}
private final Random rnd = new Random();
assertTrue(session.getRemoteTlvs().getAugmentation(Tlvs1.class).getStateful()
.getAugmentation(Stateful1.class).isInitiation());
- assertNull(session.localSessionCharacteristics().getAugmentation(Tlvs3.class)
+ assertNull(session.getLocalTlvs().getAugmentation(Tlvs3.class)
.getLspDbVersion().getLspDbVersionValue());
}
assertTrue(session.getRemoteTlvs().getAugmentation(Tlvs1.class).getStateful()
.getAugmentation(Stateful1.class).isInitiation());
- final BigInteger pceDBVersion = session.localSessionCharacteristics().getAugmentation(Tlvs3.class)
+ final BigInteger pceDBVersion = session.getLocalTlvs().getAugmentation(Tlvs3.class)
.getLspDbVersion().getLspDbVersionValue();
assertEquals(startingDBVersion, pceDBVersion);
}
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class TestingSessionListener implements PCEPSessionListener, ListenerCheck {
+public final class TestingSessionListener implements PCEPSessionListener, ListenerCheck {
private static final Logger LOG = LoggerFactory.getLogger(TestingSessionListener.class);
private final CountDownLatch sessionLatch = new CountDownLatch(1);
private PCEPSession session = null;
@Override
- public synchronized void onMessage(final PCEPSession session, final Message message) {
+ public synchronized void onMessage(final PCEPSession psession, final Message message) {
LOG.debug("Received message: {}", message);
this.messages.add(message);
}
@Override
- public void onSessionUp(final PCEPSession session) {
+ public void onSessionUp(final PCEPSession psession) {
LOG.debug("Session up.");
this.up = true;
- this.session = session;
+ this.session = psession;
this.sessionLatch.countDown();
}
@Override
- public void onSessionDown(final PCEPSession session, final Exception exception) {
+ public void onSessionDown(final PCEPSession psession, final Exception exception) {
LOG.debug("Session down. Cause : {} ", exception, exception);
this.up = false;
this.session = null;
}
@Override
- public void onSessionTerminated(final PCEPSession session, final PCEPTerminationReason cause) {
+ public void onSessionTerminated(final PCEPSession psession, final PCEPTerminationReason cause) {
LOG.debug("Session terminated. Cause : {}", cause);
}
import org.opendaylight.protocol.pcep.spi.pojo.ServiceLoaderPCEPExtensionProviderContext;
import org.opendaylight.protocol.util.InetSocketAddressUtil;
-public class PCCMock {
+public final class PCCMock {
+
+ private PCCMock() {
+ throw new UnsupportedOperationException();
+ }
public static void main(final String[] args) throws InterruptedException, ExecutionException {
Preconditions.checkArgument(args.length > 0, "Host and port of server must be provided.");
</dependency>
</dependencies>
- <build>
- <plugins>
- <plugin>
- <groupId>org.apache.felix</groupId>
- <artifactId>maven-bundle-plugin</artifactId>
- <extensions>true</extensions>
- <configuration>
- <instructions>
- <!-- This bundle works with Karaf 3 and 4.0, see https://wiki.opendaylight.org/view/Karaf_4_migration#Karaf_CLI_commands -->
- <Import-Package>
- org.apache.karaf.shell.commands;version="[3.0.0,4.1)",
- org.apache.karaf.shell.console;version="[3.0.0,4.1)",
- org.apache.karaf.shell.table;version="[3.0.0,4.1)",
- *
- </Import-Package>
- </instructions>
- </configuration>
- </plugin>
- </plugins>
- </build>
-
<scm>
<connection>scm:git:ssh://git.opendaylight.org:29418/bgpcep.git</connection>
<developerConnection>scm:git:ssh://git.opendaylight.org:29418/bgpcep.git</developerConnection>
}
@Override
- public final synchronized void onSessionUp(final PCEPSession session) {
+ public final synchronized void onSessionUp(final PCEPSession psession) {
/*
* The session went up. Look up the router in Inventory model,
* create it if it is not there (marking that fact for later
* deletion), and mark it as synchronizing. Also create it in
* the topology model, with empty LSP list.
*/
- final InetAddress peerAddress = session.getRemoteAddress();
+ final InetAddress peerAddress = psession.getRemoteAddress();
- this.syncOptimization = new SyncOptimization(session);
+ this.syncOptimization = new SyncOptimization(psession);
final TopologyNodeState state = this.serverSessionManager.takeNodeState(peerAddress,
this, isLspDbRetreived());
// takeNodeState(..) may fail when the server session manager is being restarted due to configuration change
if (state == null) {
- LOG.error("Unable to fetch topology node state for PCEP session. Closing session {}", session);
- session.close(TerminationReason.UNKNOWN);
- this.onSessionTerminated(session, new PCEPCloseTermination(TerminationReason.UNKNOWN));
+ LOG.error("Unable to fetch topology node state for PCEP session. Closing session {}", psession);
+ psession.close(TerminationReason.UNKNOWN);
+ this.onSessionTerminated(psession, new PCEPCloseTermination(TerminationReason.UNKNOWN));
return;
}
if (this.session != null || this.nodeState != null) {
- LOG.error("PCEP session is already up with {}. Closing session {}", session.getRemoteAddress(), session);
- session.close(TerminationReason.UNKNOWN);
- this.onSessionTerminated(session, new PCEPCloseTermination(TerminationReason.UNKNOWN));
+ LOG.error("PCEP session is already up with {}. Closing session {}", psession.getRemoteAddress(), psession);
+ psession.close(TerminationReason.UNKNOWN);
+ this.onSessionTerminated(psession, new PCEPCloseTermination(TerminationReason.UNKNOWN));
return;
}
- this.session = session;
+ this.session = psession;
this.nodeState = state;
this.serverSessionManager.bind(this.nodeState.getNodeId(), this.listenerState);
// Our augmentation in the topology node
final PathComputationClientBuilder pccBuilder = new PathComputationClientBuilder();
- onSessionUp(session, pccBuilder);
+ onSessionUp(psession, pccBuilder);
this.synced.set(isSynchronized());
pccBuilder.setIpAddress(IpAddressBuilder.getDefaultInstance(peerAddress.getHostAddress()));
.getPathComputationClient().getReportedLsp());
}
writeNode(pccBuilder, state, topologyAugment);
- this.listenerState.init(session);
- LOG.info("Session with {} attached to topology node {}", session.getRemoteAddress(), state.getNodeId());
+ this.listenerState.init(psession);
+ LOG.info("Session with {} attached to topology node {}", psession.getRemoteAddress(), state.getNodeId());
}
private void writeNode(final PathComputationClientBuilder pccBuilder, final TopologyNodeState state,
*/
@GuardedBy("this")
@SuppressWarnings("checkstyle:IllegalCatch")
- private synchronized void tearDown(final PCEPSession session) {
+ private synchronized void tearDown(final PCEPSession psession) {
- requireNonNull(session);
- this.serverSessionManager.releaseNodeState(this.nodeState, session, isLspDbPersisted());
+ requireNonNull(psession);
+ this.serverSessionManager.releaseNodeState(this.nodeState, psession, isLspDbPersisted());
clearNodeState();
try {
if (this.session != null) {
this.session.close();
}
- session.close();
+ psession.close();
} catch (final Exception e) {
- LOG.error("Session {} cannot be closed.", session, e);
+ LOG.error("Session {} cannot be closed.", psession, e);
}
this.session = null;
this.syncOptimization = null;
}
@Override
- public final synchronized void onSessionDown(final PCEPSession session, final Exception exception) {
- LOG.warn("Session {} went down unexpectedly", session, exception);
- tearDown(session);
+ public final synchronized void onSessionDown(final PCEPSession psession, final Exception exception) {
+ LOG.warn("Session {} went down unexpectedly", psession, exception);
+ tearDown(psession);
}
@Override
- public final synchronized void onSessionTerminated(final PCEPSession session, final PCEPTerminationReason reason) {
- LOG.info("Session {} terminated by peer with reason {}", session, reason);
- tearDown(session);
+ public final synchronized void onSessionTerminated(final PCEPSession psession, final PCEPTerminationReason reason) {
+ LOG.info("Session {} terminated by peer with reason {}", psession, reason);
+ tearDown(psession);
}
@Override
- public final synchronized void onMessage(final PCEPSession session, final Message message) {
+ public final synchronized void onMessage(final PCEPSession psession, final Message message) {
if (this.nodeState == null) {
- LOG.warn("Topology node state is null. Unhandled message {} on session {}", message, session);
- session.close(TerminationReason.UNKNOWN);
+ LOG.warn("Topology node state is null. Unhandled message {} on session {}", message, psession);
+ psession.close(TerminationReason.UNKNOWN);
return;
}
final MessageContext ctx = new MessageContext(this.nodeState.beginTransaction());
if (onMessage(ctx, message)) {
- LOG.warn("Unhandled message {} on session {}", message, session);
+ LOG.warn("Unhandled message {} on session {}", message, psession);
//cancel not supported, submit empty transaction
ctx.trans.submit();
return;
Futures.addCallback(ctx.trans.submit(), new FutureCallback<Void>() {
@Override
public void onSuccess(final Void result) {
- LOG.trace("Internal state for session {} updated successfully", session);
+ LOG.trace("Internal state for session {} updated successfully", psession);
ctx.notifyRequests();
}
@Override
public void onFailure(final Throwable throwable) {
- LOG.error("Failed to update internal state for session {}, closing it", session, throwable);
+ LOG.error("Failed to update internal state for session {}, closing it", psession, throwable);
ctx.notifyRequests();
- session.close(TerminationReason.UNKNOWN);
+ psession.close(TerminationReason.UNKNOWN);
}
}, MoreExecutors.directExecutor());
}
}
@Override
- public void onTransactionChainFailed(final TransactionChain<?, ?> chain, final AsyncTransaction<?, ?> transaction,
+ public void onTransactionChainFailed(final TransactionChain<?, ?> pchain, final AsyncTransaction<?, ?> transaction,
final Throwable cause) {
// FIXME: flip internal state, so that the next attempt to update fails, triggering node reconnect
LOG.error("Unexpected transaction failure in node {} transaction {}",
}
@Override
- public void onTransactionChainSuccessful(final TransactionChain<?, ?> chain) {
+ public void onTransactionChainSuccessful(final TransactionChain<?, ?> pchain) {
LOG.info("Node {} shutdown successfully", this.nodeId);
}
return this.status;
}
- private synchronized void setStatus(final InstructionStatus status, final Details details) {
+ private synchronized void setStatus(final InstructionStatus newStatus, final Details details) {
// Set the status
- this.status = status;
- LOG.debug("Instruction {} transitioned to status {}", this.id, status);
+ this.status = newStatus;
+ LOG.debug("Instruction {} transitioned to status {}", this.id, newStatus);
// Send out a notification
- this.queue.instructionUpdated(status, details);
+ this.queue.instructionUpdated(newStatus, details);
- switch (status) {
+ switch (newStatus) {
case Cancelled:
case Failed:
case Unknown:
}
@Override
- public void executionCompleted(final InstructionStatus status, final Details details) {
+ public void executionCompleted(final InstructionStatus newStatus, final Details details) {
final ExecutionResult<Details> result;
synchronized (this) {
cancelTimeout();
// We reuse the preconditions set down in this class
- result = new ExecutionResult<>(status, details);
- setStatus(status, details);
+ result = new ExecutionResult<>(newStatus, details);
+ setStatus(newStatus, details);
this.executionFuture.set(result);
}
}
private static final int FLAGS_SIZE = 8;
private static final Logger LOG = LoggerFactory.getLogger(ProtectionCommonParser.class);
+ protected ProtectionCommonParser() {
+
+ }
+
protected static void serializeBodyType1(final ProtectionSubobject protObj, final ByteBuf output) {
final BitArray flagBitArray = new BitArray(FLAGS_SIZE);
flagBitArray.set(SECONDARY, protObj.isSecondary());
(byte) 0xa5, 0x08, 0x00, 0x01,
(byte) 0x00, 0x00, 0x00, 0x08,
};
+
+ private TEObjectUtil() {
+
+ }
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.explicit.route.subobjects.subobject.type.path.key._case.PathKeyBuilder;
public class CommonPathKeyParser {
+ protected CommonPathKeyParser() {
+
+ }
+
public static org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.explicit.route
.subobjects.subobject.type.path.key._case.PathKey parsePathKey(final int pceIdFLength, final ByteBuf buffer) {
final int pathKey = buffer.readUnsignedShort();
package org.opendaylight.protocol.rsvp.parser.spi.subobjects;
import com.google.common.base.Preconditions;
-
import io.netty.buffer.ByteBuf;
import org.opendaylight.protocol.util.ByteBufWriteUtil;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.basic.explicit.route.subobjects.subobject.type.UnnumberedCase;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.rsvp.rev150820.basic.explicit.route.subobjects.subobject.type.unnumbered._case.UnnumberedBuilder;
public class CommonUnnumberedInterfaceSubobjectParser {
+ protected CommonUnnumberedInterfaceSubobjectParser() {
+
+ }
+
protected static UnnumberedCase parseUnnumeredInterface(final ByteBuf buffer) {
final UnnumberedBuilder ubuilder = new UnnumberedBuilder();
ubuilder.setRouterId(buffer.readUnsignedInt());
public class EROSubobjectUtilTest {
@Test(expected = UnsupportedOperationException.class)
- @SuppressWarnings({"checkstyle:IllegalCatch", "checkstyle:IllegalThrows"})
+ @SuppressWarnings({ "checkstyle:IllegalThrows", "checkstyle:avoidHidingCauseException" })
public void testPrivateConstructor() throws Throwable {
final Constructor<EROSubobjectUtil> c = EROSubobjectUtil.class.getDeclaredConstructor();
c.setAccessible(true);
}
@Test(expected = UnsupportedOperationException.class)
- @SuppressWarnings("checkstyle:IllegalThrows")
+ @SuppressWarnings({ "checkstyle:IllegalThrows", "checkstyle:avoidHidingCauseException" })
public void testPrivateConstructor() throws Throwable {
final Constructor<ServiceLoaderRSVPExtensionProviderContext> c =
ServiceLoaderRSVPExtensionProviderContext.class.getDeclaredConstructor();
<?xml version="1.0" encoding="UTF-8"?>
<!--
- ~ Copyright (c) 2017 AT&T Intellectual Property. All rights reserved.
+ ~ Copyright (c) 2018 AT&T Intellectual Property. All rights reserved.
~
~ This program and the accompanying materials are made available under the
~ terms of the Eclipse Public License v1.0 which accompanies this distribution,
Code Review / bgpcep.git / commitdiff