package io.fd.honeycomb.v3po.impl;
+import com.google.common.primitives.Ints;
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.Futures;
import java.math.BigInteger;
import java.net.InetAddress;
-
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.interfaces.state._interface.l2.interconnection.BridgeBasedBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.interfaces.state._interface.l2.interconnection.XconnectBasedBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.openvpp.vppjapi.vppApi;
import org.openvpp.vppjapi.vppBridgeDomainDetails;
import org.openvpp.vppjapi.vppBridgeDomainInterfaceDetails;
import org.openvpp.vppjapi.vppIPv4Address;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.primitives.Ints;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
/*
* VPP API Class overriding interface details callback
*/
public class V3poApiRequest extends V3poRequest {
private static final Logger LOG = LoggerFactory.getLogger(V3poApiRequest.class);
public String ifNames = "";
- private VppPollOperDataImpl caller;
+ private final VppPollOperDataImpl caller;
+ private final vppApi api;
- public V3poApiRequest(VppPollOperDataImpl vppPollOperData) {
+ public V3poApiRequest(final vppApi api, final VppPollOperDataImpl vppPollOperData) {
+ this.api = api;
caller = vppPollOperData;
}
- private InstanceIdentifier<Interface> getStateInterfaceIid(String interfaceName) {
+ private InstanceIdentifier<Interface> getStateInterfaceIid(final String interfaceName) {
return InstanceIdentifier.create(InterfacesState.class).child(Interface.class,
new InterfaceKey(interfaceName));
}
-
- private InstanceIdentifier<Interface2> getStateInterfaceIpId(InstanceIdentifier<Interface> iid) {
+
+ private InstanceIdentifier<Interface2> getStateInterfaceIpId(final InstanceIdentifier<Interface> iid) {
return iid.augmentation(Interface2.class);
}
-
- private InstanceIdentifier<Statistics> getStateInterfaceStatsId(InstanceIdentifier<Interface> iid) {
+
+ private InstanceIdentifier<Statistics> getStateInterfaceStatsId(final InstanceIdentifier<Interface> iid) {
return iid.child(Statistics.class);
}
-
- private static Counter64 getCounter64(long num) {
+
+ private static Counter64 getCounter64(final long num) {
return new Counter64(BigInteger.valueOf(num));
}
-
- private static Counter32 getCounter32(long num) {
+
+ private static Counter32 getCounter32(final long num) {
return new Counter32(num);
}
-
- private Statistics buildInterfaceStatistics(vppInterfaceCounters ifCounters) {
+
+ private Statistics buildInterfaceStatistics(final vppInterfaceCounters ifCounters) {
if (ifCounters == null) {
return null;
}
StatisticsBuilder statsBuilder = new StatisticsBuilder();
-
+
statsBuilder.setInBroadcastPkts(getCounter64(ifCounters.rxBroadcast));
statsBuilder.setInDiscards(getCounter32(ifCounters.rxDiscard));
statsBuilder.setInErrors(getCounter32(ifCounters.rxError));
statsBuilder.setOutMulticastPkts(getCounter64(ifCounters.txMulticast));
statsBuilder.setOutOctets(getCounter64(ifCounters.txOctets));
statsBuilder.setOutUnicastPkts(getCounter64(ifCounters.txUnicast));
-
+
VppInterfaceStatisticsAugmentationBuilder statsAugBuilder =
new VppInterfaceStatisticsAugmentationBuilder();
statsAugBuilder.setInErrorsMiss(getCounter64(ifCounters.rxMiss));
statsAugBuilder.setInErrorsNoBuf(getCounter64(ifCounters.rxFifoFull)); // FIXME? Is this right?
statsAugBuilder.setOutDiscardsFifoFull(getCounter64(ifCounters.txFifoFull));
-
+
statsBuilder.addAugmentation(VppInterfaceStatisticsAugmentation.class,
statsAugBuilder.build());
-
+
return statsBuilder.build();
}
- private static String getMacAddress(byte[] mac) {
+ private static String getMacAddress(final byte[] mac) {
StringBuilder sb = new StringBuilder(18);
for (byte b : mac) {
if (sb.length() > 0) {
}
return sb.toString();
}
-
+
private static final Gauge64 vppSpeed0 = new Gauge64(BigInteger.ZERO);
- private static final Gauge64 vppSpeed1 = new Gauge64(BigInteger.valueOf(10 * 1000000));
- private static final Gauge64 vppSpeed2 = new Gauge64(BigInteger.valueOf(100 * 1000000));
- private static final Gauge64 vppSpeed4 = new Gauge64(BigInteger.valueOf(1000 * 1000000));
- private static final Gauge64 vppSpeed8 = new Gauge64(BigInteger.valueOf(10000L * 1000000));
- private static final Gauge64 vppSpeed16 = new Gauge64(BigInteger.valueOf(40000L * 1000000));
- private static final Gauge64 vppSpeed32 = new Gauge64(BigInteger.valueOf(100000L * 1000000));
-
- private static Gauge64 getSpeed(byte vppSpeed) {
+ private static final Gauge64 vppSpeed1 = new Gauge64(BigInteger.valueOf(10 * 1000000));
+ private static final Gauge64 vppSpeed2 = new Gauge64(BigInteger.valueOf(100 * 1000000));
+ private static final Gauge64 vppSpeed4 = new Gauge64(BigInteger.valueOf(1000 * 1000000));
+ private static final Gauge64 vppSpeed8 = new Gauge64(BigInteger.valueOf(10000L * 1000000));
+ private static final Gauge64 vppSpeed16 = new Gauge64(BigInteger.valueOf(40000L * 1000000));
+ private static final Gauge64 vppSpeed32 = new Gauge64(BigInteger.valueOf(100000L * 1000000));
+
+ private static Gauge64 getSpeed(final byte vppSpeed) {
switch (vppSpeed) {
case 1: return vppSpeed1;
case 2: return vppSpeed2;
default: return vppSpeed0;
}
}
-
- private static String ipv4IntToString(int ip) {
+
+ private static String ipv4IntToString(final int ip) {
InetAddress addr = null;
byte[] bytes = Ints.toByteArray(ip);
try {
return addr.getHostAddress();
}
- private Interface buildStateInterface(int ifIndex,
- String interfaceName,
- int supIfIndex,
- byte[] physAddr,
- byte adminUp, byte linkUp,
- byte linkDuplex, byte linkSpeed,
- int subId, byte subDot1ad,
- byte subNumberOfTags,
- int subOuterVlanId,
- int subInnerVlanId,
- byte subExactMatch,
- byte subDefault,
- byte subOuterVlanIdAny,
- byte subInnerVlanIdAny,
- int vtrOp, int vtrPushDot1q,
- int vtrTag1, int vtrTag2,
- Statistics stats) {
+ private Interface buildStateInterface(final int ifIndex,
+ final String interfaceName,
+ final int supIfIndex,
+ final byte[] physAddr,
+ final byte adminUp, final byte linkUp,
+ final byte linkDuplex, final byte linkSpeed,
+ final int subId, final byte subDot1ad,
+ final byte subNumberOfTags,
+ final int subOuterVlanId,
+ final int subInnerVlanId,
+ final byte subExactMatch,
+ final byte subDefault,
+ final byte subOuterVlanIdAny,
+ final byte subInnerVlanIdAny,
+ final int vtrOp, final int vtrPushDot1q,
+ final int vtrTag1, final int vtrTag2,
+ final Statistics stats) {
InterfaceBuilder ifBuilder = new InterfaceBuilder();
java.lang.Class<? extends InterfaceType> ifType;
-
+
// FIXME: missing types for virtualethernet, subinterface, tap interface etc
if (interfaceName.startsWith("loop")) {
ifType = SoftwareLoopback.class;
.setType(ifType)
.setAdminStatus((adminUp == 0 ? AdminStatus.Down : AdminStatus.Up))
.setOperStatus((linkUp == 0 ? OperStatus.Down : OperStatus.Up));
-/*
+/*
DataContainerNodeBuilder<NodeIdentifierWithPredicates, MapEntryNode> builder = ImmutableNodes.mapEntryBuilder()
.withNodeIdentifier(new NodeIdentifierWithPredicates(Interface.QNAME, NAME_QNAME, interfaceName));
builder.withChild(ImmutableNodes.leafNode(IF_TYPE, SoftwareLoopback.QNAME))*/
-
+
// subinterface?
if (ifIndex != supIfIndex) {
// TODO: get name and set
}
-
+
if (physAddr != null) {
ifBuilder.setPhysAddress(new PhysAddress(getMacAddress(physAddr)));
}
ifBuilder.setSpeed(getSpeed(linkSpeed));
-
+
if (stats != null) {
ifBuilder.setStatistics(stats);
}
- int bdId = this.bridgeDomainIdFromInterfaceName(interfaceName);
- vppBridgeDomainDetails bd = (bdId != -1 ? this.getBridgeDomainDetails(bdId) : null);
-
+ int bdId = api.bridgeDomainIdFromInterfaceName(interfaceName);
+ vppBridgeDomainDetails bd = (bdId != -1 ? api.getBridgeDomainDetails(bdId) : null);
+
String bdName = null;
short splitHorizonGroup = 0;
boolean bvi = false;
-
+
if (bd != null) {
bdName = bd.name;
- for (int ifIdx = 0; ifIdx < bd.interfaces.length; ifIdx++) {
- vppBridgeDomainInterfaceDetails bdIf = bd.interfaces[ifIdx];
-
+ for (vppBridgeDomainInterfaceDetails bdIf : bd.interfaces) {
if (bdIf.interfaceName != interfaceName) {
continue;
}
if (bd.bviInterfaceName == interfaceName) {
bvi = true;
}
- splitHorizonGroup = (short)bdIf.splitHorizonGroup;
+ splitHorizonGroup = bdIf.splitHorizonGroup;
}
}
VppInterfaceStateAugmentationBuilder vppIfStateAugBuilder =
new VppInterfaceStateAugmentationBuilder();
- vppIfStateAugBuilder.setDescription(this.getInterfaceDescription(interfaceName));
+ vppIfStateAugBuilder.setDescription(api.getInterfaceDescription(interfaceName));
setStateInterfaceL2(vppIfStateAugBuilder, bdId != -1, false, null,
bdName, splitHorizonGroup, bvi);
"ACME Inc.", 1234);
}
- vppVxlanTunnelDetails[] vxlanDet = this.vxlanTunnelDump(ifIndex);
+ vppVxlanTunnelDetails[] vxlanDet = api.vxlanTunnelDump(ifIndex);
if (null != vxlanDet && vxlanDet.length >= 1) {
setStateInterfaceVxlan(vppIfStateAugBuilder, vxlanDet[0].srcAddress,
vxlanDet[0].dstAddress, vxlanDet[0].vni,
ifBuilder.addAugmentation(VppInterfaceStateAugmentation.class,
vppIfStateAugBuilder.build());
-
+
InterfaceStateIpv4Builder ipv4Builder = new InterfaceStateIpv4Builder();
// TODO ipv4Builder.setMtu(1234);
-
+
InetAddress addr = null;
-
- vppIPv4Address[] ipv4Addrs = ipv4AddressDump(interfaceName);
+
+ vppIPv4Address[] ipv4Addrs = api.ipv4AddressDump(interfaceName);
if (ipv4Addrs != null) {
for (vppIPv4Address vppAddr : ipv4Addrs) {
if (null == vppAddr) {
LOG.error("ipv4 address structure in null");
continue;
}
-
+
// FIXME: vppIPv4Address and vppIPv6 address can be the same if both will use
// byte array for ip
byte[] bytes = Ints.toByteArray(vppAddr.ip);
e.printStackTrace();
continue;
}
-
+
ipv4Builder.addAddress(addr.getHostAddress(), vppAddr.prefixLength, IpAddressOrigin.Static);
}
}
-
+
InterfaceStateIpv6Builder ipv6Builder = new InterfaceStateIpv6Builder();
// TODO ipv6Builder.setMtu(1234);
-
- vppIPv6Address[] ipv6Addrs = ipv6AddressDump(interfaceName);
+
+ vppIPv6Address[] ipv6Addrs = api.ipv6AddressDump(interfaceName);
if (ipv6Addrs != null) {
for (vppIPv6Address vppAddr : ipv6Addrs) {
if (null == vppAddr) {
LOG.error("ipv6 address structure in null");
continue;
}
-
+
byte[] bytes = vppAddr.ip;
try {
addr = InetAddress.getByAddress(bytes);
e.printStackTrace();
continue;
}
-
+
ipv6Builder.addAddress(addr.getHostAddress(), vppAddr.prefixLength, IpAddressOrigin.Static);
}
}
Interface2Builder ipBuilder = new Interface2Builder();
-
+
ipBuilder.setIpv4(ipv4Builder.build());
ipBuilder.setIpv6(ipv6Builder.build());
-
+
ifBuilder.addAugmentation(Interface2.class, ipBuilder.build());
-
+
return ifBuilder.build();
}
-
+
private void setStateInterfaceL2(
- VppInterfaceStateAugmentationBuilder augBuilder,
- boolean isL2BridgeBased, boolean isXconnect,
- String xconnectOutgoingInterface,
- String bdName, short splitHorizonGroup, boolean bvi) {
+ final VppInterfaceStateAugmentationBuilder augBuilder,
+ final boolean isL2BridgeBased, final boolean isXconnect,
+ final String xconnectOutgoingInterface,
+ final String bdName, final short splitHorizonGroup, final boolean bvi) {
L2Builder l2Builder = new L2Builder();
-
+
if (isXconnect) {
l2Builder.setInterconnection(
new XconnectBasedBuilder()
.setBridgedVirtualInterface(bvi)
.build());
}
-
+
augBuilder.setL2(l2Builder.build());
}
-
+
private void setStateInterfaceEthernet(
- VppInterfaceStateAugmentationBuilder augBuilder,
- boolean isFullDuplex, String manufacturerDesc, Integer mtu) {
+ final VppInterfaceStateAugmentationBuilder augBuilder,
+ final boolean isFullDuplex, final String manufacturerDesc, final Integer mtu) {
EthernetBuilder ethBuilder = new EthernetBuilder();
ethBuilder.setDuplex((isFullDuplex ? Duplex.Full : Duplex.Half))
}
private void setStateInterfaceVxlan(
- VppInterfaceStateAugmentationBuilder augBuilder, int srcAddress,
- int dstAddress, int vni, int encapVrfId) {
+ final VppInterfaceStateAugmentationBuilder augBuilder, final int srcAddress,
+ final int dstAddress, final int vni, final int encapVrfId) {
String srcAddressStr = ipv4IntToString(srcAddress);
String dstAddressStr = ipv4IntToString(dstAddress);
augBuilder.setVxlan(vxlan);
}
- private void writeToIfState(InstanceIdentifier<Interface> iid,
- Interface intf) {
+ private void writeToIfState(final InstanceIdentifier<Interface> iid,
+ final Interface intf) {
DataBroker db = caller.getDataBroker();
WriteTransaction transaction = db.newWriteOnlyTransaction();
// TODO: how to delete existing interfaces that disappeared? (reset it before each dumpInterfaces call?)
/*LOG.info("VPPOPER-INFO: Adding interface " + intf.getName()
+ " to oper DataStore.");*/
transaction.put(LogicalDatastoreType.OPERATIONAL, iid, intf);
-
+
CheckedFuture<Void, TransactionCommitFailedException> future =
transaction.submit();
Futures.addCallback(future, new LoggingFuturesCallBack<Void>(
"VPPOPER-WARNING: Failed to write "
+ "interface to ietf-interfaces state", LOG));
}
-
- private void processInterfaces(vppInterfaceDetails[] ifaces) {
+
+ private void processInterfaces(final vppInterfaceDetails[] ifaces) {
for (vppInterfaceDetails swIf : ifaces) {
interfaceDetails(swIf);
}
}
-
+
/**
* TODO-ADD-JAVADOC.
*/
public void swInterfaceDumpAll() {
vppInterfaceDetails[] ifaces;
-
- ifaces = swInterfaceDump((byte) 1, "Ether".getBytes());
+
+ ifaces = api.swInterfaceDump((byte) 1, "Ether".getBytes());
processInterfaces(ifaces);
-
- ifaces = swInterfaceDump((byte) 1, "lo".getBytes());
+
+ ifaces = api.swInterfaceDump((byte) 1, "lo".getBytes());
processInterfaces(ifaces);
-
- ifaces = swInterfaceDump((byte) 1, "vxlan".getBytes());
+
+ ifaces = api.swInterfaceDump((byte) 1, "vxlan".getBytes());
processInterfaces(ifaces);
-
- ifaces = swInterfaceDump((byte) 1, "l2tpv3_tunnel".getBytes());
+
+ ifaces = api.swInterfaceDump((byte) 1, "l2tpv3_tunnel".getBytes());
processInterfaces(ifaces);
-
- ifaces = swInterfaceDump((byte) 1, "tap".getBytes());
+
+ ifaces = api.swInterfaceDump((byte) 1, "tap".getBytes());
processInterfaces(ifaces);
}
- private void interfaceDetails(vppInterfaceDetails swIf) {
+ private void interfaceDetails(final vppInterfaceDetails swIf) {
/*LOG.info("Got interface {} (idx: {}) adminUp: {} linkUp: {} duplex: {} speed: {} subId: {}",
swIf.interfaceName, swIf.ifIndex, swIf.adminUp, swIf.linkUp, swIf.linkDuplex, swIf.linkSpeed, swIf.subId);*/
- vppInterfaceCounters ifCounters = getInterfaceCounters(swIf.ifIndex);
+ vppInterfaceCounters ifCounters = api.getInterfaceCounters(swIf.ifIndex);
InstanceIdentifier<Interface> iid = getStateInterfaceIid(swIf.interfaceName);
Statistics stats = buildInterfaceStatistics(ifCounters);
-
+
Interface intf = buildStateInterface(swIf.ifIndex, swIf.interfaceName,
- swIf.supIfIndex, swIf.physAddr,
+ swIf.supIfIndex, swIf.physAddr,
swIf.adminUp, swIf.linkUp,
swIf.linkDuplex, swIf.linkSpeed,
swIf.subId, swIf.subDot1ad,
- swIf.subNumberOfTags,
+ swIf.subNumberOfTags,
swIf.subOuterVlanId,
swIf.subInnerVlanId,
- swIf.subExactMatch, swIf.subDefault,
+ swIf.subExactMatch, swIf.subDefault,
swIf.subOuterVlanIdAny,
swIf.subInnerVlanIdAny,
swIf.vtrOp, swIf.vtrPushDot1q,
package io.fd.honeycomb.v3po.impl;
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.Futures;
+import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Timer;
import java.util.TimerTask;
-
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.util.concurrent.CheckedFuture;
-import com.google.common.util.concurrent.Futures;
-
public class V3poProvider implements BindingAwareProvider, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(V3poProvider.class);
private RpcRegistration<V3poService> v3poService;
private VppIetfInterfaceListener vppInterfaceListener;
private VppBridgeDomainListener vppBridgeDomainListener;
- private static final vppApi api = new vppApi();
- private static DataBroker db;
+ private vppApi api;
+ private DataBroker db;
VppPollOperDataImpl vppPollOperData;
- private void writeToBridgeDomain(String bdName, Boolean flood,
- Boolean forward, Boolean learn,
- Boolean unknownUnicastFlood,
- Boolean arpTermination) {
+ private void writeToBridgeDomain(final String bdName, final Boolean flood,
+ final Boolean forward, final Boolean learn,
+ final Boolean unknownUnicastFlood,
+ final Boolean arpTermination) {
BridgeDomainBuilder bdBuilder = new BridgeDomainBuilder();
bdBuilder.setName(bdName);
bdBuilder.setArpTermination(arpTermination);
LOG.info("VPPCFG-INFO: Adding Bridge Domain " + bdName + " to DataStore.");
- InstanceIdentifier<BridgeDomain> iid =
+ InstanceIdentifier<BridgeDomain> iid =
InstanceIdentifier.create(Vpp.class)
.child(BridgeDomains.class)
.child(BridgeDomain.class, new BridgeDomainKey(bdName));
"VPPCFG-WARNING: Failed to write bridge domain " + bdName + " to Bridge Domains", LOG));
}
- private void writeIpv4AddressToInterface(String name, Ipv4AddressNoZone ipv4Addr, short plen) {
+ private void writeIpv4AddressToInterface(final String name, final Ipv4AddressNoZone ipv4Addr, final short plen) {
AddressKey addrKey = new AddressKey(ipv4Addr);
AddressBuilder addrBuilder = new AddressBuilder();
PrefixLength prefixLen = new PrefixLengthBuilder().setPrefixLength(plen).build();
ifBuilder.addAugmentation(Interface1.class, if1Builder.build());
LOG.info("VPPCFG-INFO: Adding ipv4 address {} to interface {} to DataStore.", ipv4Addr, name);
- InstanceIdentifier<Interface> iid =
+ InstanceIdentifier<Interface> iid =
InstanceIdentifier.create(Interfaces.class)
.child(Interface.class, new InterfaceKey(name));
WriteTransaction transaction = db.newWriteOnlyTransaction();
"VPPCFG-WARNING: Failed to write " + name + "interface to ietf-interfaces", LOG));
}
- private void writeToInterface(String name, String description,
- Boolean enabled, String bdName, int vrfId) {
+ private void writeToInterface(final String name, final String description,
+ final Boolean enabled, final String bdName, final int vrfId) {
VppInterfaceAugmentationBuilder ifAugBuilder = new VppInterfaceAugmentationBuilder();
EthernetBuilder ethBuilder = new EthernetBuilder();
bridgeBuilder.setBridgeDomain(bdName);
bridgeBuilder.setSplitHorizonGroup((short)0);
bridgeBuilder.setBridgedVirtualInterface(false);
-
+
L2Builder l2Builder = new L2Builder();
l2Builder.setInterconnection(bridgeBuilder.build());
ifAugBuilder.setL2(l2Builder.build());
Vpp vpp = new VppBuilder().build();
transaction.put(LogicalDatastoreType.CONFIGURATION, viid, vpp);
CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
- Futures.addCallback(future, new
+ Futures.addCallback(future, new
LoggingFuturesCallBack<>("VPPCFG-WARNING: Failed to create Vpp "
+ "configuration db.",
LOG));
Interfaces intf = new InterfacesBuilder().build();
transaction.put(LogicalDatastoreType.CONFIGURATION, iid, intf);
future = transaction.submit();
- Futures.addCallback(future, new
+ Futures.addCallback(future, new
LoggingFuturesCallBack<>("VPPCFG-WARNING: Failed to create IETF "
+ "Interface list configuration db.",
LOG));
false /*arpTermination*/);
- writeToInterface("TenGigabitEthernet86/0/1",
+ writeToInterface("TenGigabitEthernet86/0/1",
"Physical 10GbE Interface (Transport)",
true, null, 7);
writeToInterface("TenGigabitEthernet86/0/0", "Physical 10GbE Interface",
Futures.addCallback(tx.submit(), new LoggingFuturesCallBack<>(
"VPPOPER-WARNING: Failed to create IETF " + "Interface state list operational db.", LOG));
}
-
+
private void startOperationalUpdateTimer() {
Timer timer = new Timer();
-
+
// fire task after 1 second and then repeat each 10 seconds
timer.scheduleAtFixedRate(new TimerTask() {
@Override
}
@Override
- public void onSessionInitiated(ProviderContext session) {
+ public void onSessionInitiated(final ProviderContext session) {
LOG.info("VPP-INFO: V3poProvider Session Initiated");
- int rv = api.clientConnect("v3poODL");
- LOG.info("VPP-INFO: VPP api client connection return value = {}", rv);
- if (rv != 0) {
- LOG.error("VPP-ERROR: VPP api client connection failed: return value = {}", rv);
+
+ try {
+ api = new vppApi("v3poODL");
+ } catch (IOException e) {
+ LOG.error("VPP-ERROR: VPP api client connection failed", e);
return;
}
+
+ LOG.info("VPP-INFO: VPP api client connection established");
+
db = session.getSALService(DataBroker.class);
initializeVppConfig();
initVppOperational();
- vppPollOperData = new VppPollOperDataImpl(db);
+ vppPollOperData = new VppPollOperDataImpl(api, db);
v3poService = session.addRpcImplementation(V3poService.class,
vppPollOperData);
startOperationalUpdateTimer();
if (v3poService != null) {
v3poService.close();
}
+ if (api != null) {
+ api.close();
+ }
}
}
package io.fd.honeycomb.v3po.impl;
-import java.util.HashMap;
-import java.util.concurrent.Future;
-
import com.google.common.util.concurrent.CheckedFuture;
import com.google.common.util.concurrent.Futures;
+import java.util.HashMap;
+import java.util.concurrent.Future;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
+import org.openvpp.vppjapi.vppApi;
import org.openvpp.vppjapi.vppBridgeDomainDetails;
import org.openvpp.vppjapi.vppBridgeDomainInterfaceDetails;
import org.openvpp.vppjapi.vppL2Fib;
public class VppPollOperDataImpl implements V3poService {
private static final Logger LOG = LoggerFactory.getLogger(VppPollOperDataImpl.class);
private vppVersion version;
- private DataBroker db;
+ private final DataBroker db;
private int[] bdIds;
- private HashMap<Integer, vppL2Fib[]> l2fibByBdId = new HashMap<Integer, vppL2Fib[]>();
+ private final HashMap<Integer, vppL2Fib[]> l2fibByBdId = new HashMap<Integer, vppL2Fib[]>();
+ private final vppApi api;
/**
* TODO-ADD-JAVADOC.
+ * @param api
*/
- public VppPollOperDataImpl(DataBroker dataBroker) {
+ public VppPollOperDataImpl(final vppApi api, final DataBroker dataBroker) {
+ this.api = api;
db = dataBroker;
}
* interfaces names
*/
public String updateOperational() {
- V3poApiRequest api = new V3poApiRequest(this);
+ V3poApiRequest req = new V3poApiRequest(api, this);
version = api.getVppVersion();
-
+
bdIds = api.bridgeDomainDump(-1);
-
+
// TODO: we don't need to cache BDs now that we got rid of callbacks
l2fibByBdId.clear();
if (bdIds != null) {
- for (int idx = 0; idx < bdIds.length; idx++) {
- l2fibByBdId.put(bdIds[idx], api.l2FibTableDump(bdIds[idx]));
+ for (int bdId : bdIds) {
+ l2fibByBdId.put(bdId, api.l2FibTableDump(bdId));
}
}
- api.swInterfaceDumpAll();
-
+ req.swInterfaceDumpAll();
+
// build vpp-state
VppStateCustomBuilder stateBuilder = new VppStateCustomBuilder();
-
+
// bridge domains
- for (int i = 0; i < bdIds.length; i++) {
- vppBridgeDomainDetails bd = api.getBridgeDomainDetails(bdIds[i]);
- VppStateBridgeDomainBuilder bdBuilder =
+ for (int bdId : bdIds) {
+ vppBridgeDomainDetails bd = api.getBridgeDomainDetails(bdId);
+ VppStateBridgeDomainBuilder bdBuilder =
new VppStateBridgeDomainBuilder(
- bd.name, bd.flood, bd.uuFlood,
+ bd.name, bd.flood, bd.uuFlood,
bd.arpTerm, bd.forward, bd.learn);
-
- for (int ifIdx = 0; ifIdx < bd.interfaces.length; ifIdx++) {
- vppBridgeDomainInterfaceDetails bdIf = bd.interfaces[ifIdx];
- bdBuilder.addInterface(bdIf.interfaceName,
- bd.bviInterfaceName == bdIf.interfaceName,
+
+ for (vppBridgeDomainInterfaceDetails bdIf : bd.interfaces) {
+ bdBuilder.addInterface(bdIf.interfaceName,
+ bd.bviInterfaceName == bdIf.interfaceName,
bdIf.splitHorizonGroup);
}
-
- vppL2Fib[] bdFibs = l2fibByBdId.get(bdIds[i]);
- for (int fibIdx = 0; fibIdx < bdFibs.length; fibIdx++) {
- vppL2Fib fib = bdFibs[fibIdx];
+ vppL2Fib[] bdFibs = l2fibByBdId.get(bdId);
+
+ for (vppL2Fib fib : bdFibs) {
bdBuilder.addL2Fib(fib.filter, fib.bridgedVirtualInterface,
fib.outgoingInterface, fib.physAddress,
fib.staticConfig);
}
-
+
stateBuilder.addBridgeDomain(bdBuilder.build());
}
-
+
stateBuilder.setVersion(version);
-
+
// write to oper
writeVppState(getVppStateIid(), stateBuilder.build());
-
- return api.ifNames;
+
+ return req.ifNames;
}
-
+
@Override
public Future<RpcResult<VppPollOperDataOutput>> vppPollOperData() {
String ifNames = updateOperational();
-
+
VppPollOperDataOutput output = new VppPollOperDataOutputBuilder()
.setStatus(new Long(1)).build();
return RpcResultBuilder.success(output).buildFuture();
}
-
+
private InstanceIdentifier<VppState> getVppStateIid() {
return (InstanceIdentifier.create(VppState.class));
}
-
- private void writeVppState(InstanceIdentifier<VppState> iid, VppState vppState) {
+
+ private void writeVppState(final InstanceIdentifier<VppState> iid, final VppState vppState) {
WriteTransaction transaction = db.newWriteOnlyTransaction();
//LOG.info("VPPOPER-INFO: Writing vpp-state to oper DataStore.");
transaction.put(LogicalDatastoreType.OPERATIONAL, iid, vppState);
-
+
CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
Futures.addCallback(future, new LoggingFuturesCallBack<Void>(
"VPPOPER-WARNING: Failed to write vpp-state to oper datastore", LOG));
Code Review / hc2vpp.git / commitdiff