From: Chi-Vien Ly Date: Tue, 24 Dec 2013 16:22:31 +0000 (+0000) Subject: Merge "Add some log messages in case controller failed to add connected node." X-Git-Tag: jenkins-controller-bulk-release-prepare-only-2-1~150 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?p=controller.git;a=commitdiff_plain;h=0c5fea94e6b10494863a9ed3603279919cb3ef1c;hp=6b6a68c9f2623f32f7b6d5df87209dfe03bc3907 Merge "Add some log messages in case controller failed to add connected node." --- diff --git a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/AbstractConfigTest.java b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/AbstractConfigTest.java index fa9e0f169e..81b0921660 100644 --- a/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/AbstractConfigTest.java +++ b/opendaylight/config/config-manager/src/test/java/org/opendaylight/controller/config/manager/impl/AbstractConfigTest.java @@ -7,8 +7,13 @@ */ package org.opendaylight.controller.config.manager.impl; +import com.google.common.base.Preconditions; +import com.google.common.collect.Maps; +import junit.framework.Assert; import org.junit.After; import org.mockito.Matchers; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; import org.opendaylight.controller.config.api.jmx.CommitStatus; import org.opendaylight.controller.config.manager.impl.factoriesresolver.ModuleFactoriesResolver; import org.opendaylight.controller.config.manager.impl.jmx.BaseJMXRegistrator; @@ -26,14 +31,20 @@ import javax.management.InstanceAlreadyExistsException; import javax.management.MBeanServer; import javax.management.ObjectName; import java.io.Closeable; +import java.io.InputStream; import java.lang.management.ManagementFactory; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; import java.util.Dictionary; +import java.util.List; +import java.util.Map; import java.util.Set; import static org.junit.Assert.assertEquals; import static org.mockito.Matchers.any; +import static org.mockito.Mockito.doAnswer; import static org.mockito.Mockito.doNothing; -import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; /** @@ -55,6 +66,10 @@ public abstract class AbstractConfigTest extends protected BundleContext mockedContext = mock(BundleContext.class); protected ServiceRegistration mockedServiceRegistration; + protected Map getBundleContextServiceRegistrationHandlers() { + return Maps.newHashMap(); + } + // this method should be called in @Before protected void initConfigTransactionManagerImpl( ModuleFactoriesResolver resolver) { @@ -63,17 +78,14 @@ public abstract class AbstractConfigTest extends configRegistryJMXRegistrator = new ConfigRegistryJMXRegistrator( platformMBeanServer); - this.mockedServiceRegistration = mock(ServiceRegistration.class); - doNothing().when(mockedServiceRegistration).unregister(); - doReturn(mockedServiceRegistration).when(mockedContext).registerService( - Matchers.any(String[].class), any(Closeable.class), - any(Dictionary.class)); + initBundleContext(); internalJmxRegistrator = new InternalJMXRegistrator(platformMBeanServer); baseJmxRegistrator = new BaseJMXRegistrator(internalJmxRegistrator); configRegistry = new ConfigRegistryImpl(resolver, platformMBeanServer, baseJmxRegistrator); + try { configRegistryJMXRegistrator.registerToJMX(configRegistry); } catch (InstanceAlreadyExistsException e) { @@ -82,6 +94,35 @@ public abstract class AbstractConfigTest extends configRegistryClient = new ConfigRegistryJMXClient(platformMBeanServer); } + private void initBundleContext() { + this.mockedServiceRegistration = mock(ServiceRegistration.class); + doNothing().when(mockedServiceRegistration).unregister(); + + RegisterServiceAnswer answer = new RegisterServiceAnswer(); + + doAnswer(answer).when(mockedContext).registerService(Matchers.any(String[].class), + any(Closeable.class), Matchers.>any()); + doAnswer(answer).when(mockedContext).registerService(Matchers.>any(), any(Closeable.class), + Matchers.>any()); + } + + + public Collection getFilesAsInputStreams(List paths) { + final Collection resources = new ArrayList<>(); + List failedToFind = new ArrayList<>(); + for (String path : paths) { + InputStream resourceAsStream = getClass().getResourceAsStream(path); + if (resourceAsStream == null) { + failedToFind.add(path); + } else { + resources.add(resourceAsStream); + } + } + Assert.assertEquals("Some files were not found", Collections.emptyList(), failedToFind); + + return resources; + } + @After public final void cleanUpConfigTransactionManagerImpl() { configRegistryJMXRegistrator.close(); @@ -154,4 +195,35 @@ public abstract class AbstractConfigTest extends Class configBeanClass, String implementationName) { return new ClassBasedModuleFactory(implementationName, configBeanClass); } + + + public static interface BundleContextServiceRegistrationHandler { + + void handleServiceRegistration(Object serviceInstance); + + } + + private class RegisterServiceAnswer implements Answer { + @Override + public Object answer(InvocationOnMock invocation) throws Throwable { + Object[] args = invocation.getArguments(); + + Preconditions.checkArgument(args.length == 3); + + Preconditions.checkArgument(args[0] instanceof Class); + Class serviceType = (Class) args[0]; + Object serviceInstance = args[1]; + + BundleContextServiceRegistrationHandler serviceRegistrationHandler = getBundleContextServiceRegistrationHandlers() + .get(serviceType); + + Preconditions.checkArgument(serviceType.isAssignableFrom(serviceInstance.getClass())); + + if (serviceRegistrationHandler != null) { + serviceRegistrationHandler.handleServiceRegistration(serviceType.cast(serviceInstance)); + } + + return mockedServiceRegistration; + } + } } diff --git a/opendaylight/config/yang-store-impl/src/main/java/org/opendaylight/controller/config/yang/store/impl/MbeParser.java b/opendaylight/config/yang-store-impl/src/main/java/org/opendaylight/controller/config/yang/store/impl/MbeParser.java index 211da6bfef..2be6c81ee7 100644 --- a/opendaylight/config/yang-store-impl/src/main/java/org/opendaylight/controller/config/yang/store/impl/MbeParser.java +++ b/opendaylight/config/yang-store-impl/src/main/java/org/opendaylight/controller/config/yang/store/impl/MbeParser.java @@ -9,7 +9,6 @@ package org.opendaylight.controller.config.yang.store.impl; import com.google.common.collect.Lists; import com.google.common.collect.Maps; -import com.google.common.collect.Sets; import org.apache.commons.io.IOUtils; import org.opendaylight.controller.config.yang.store.api.YangStoreException; import org.opendaylight.controller.config.yangjmxgenerator.ModuleMXBeanEntry; @@ -22,13 +21,10 @@ import org.opendaylight.yangtools.yang.model.api.Module; import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl; -import java.io.ByteArrayInputStream; import java.io.IOException; import java.io.InputStream; -import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; -import java.util.List; import java.util.Map; import java.util.Map.Entry; @@ -37,26 +33,11 @@ public class MbeParser { public YangStoreSnapshotImpl parseYangFiles( Collection allInput) throws YangStoreException { - YangParserImpl parser = new YangParserImpl(); + YangParserImpl parser = YangParserWrapper.getYangParserInstance(); - List bufferedInputStreams = new ArrayList<>(); - for (InputStream is : allInput) { - String content; - try { - content = IOUtils.toString(is); - } catch (IOException e) { - throw new YangStoreException("Can not get yang as String from " - + is, e); - } - InputStream buf = new ByteArrayInputStream(content.getBytes()); - bufferedInputStreams.add(buf); - } - - Map allYangModules = parser - .parseYangModelsFromStreamsMapped(bufferedInputStreams); + Map allYangModules = YangParserWrapper.parseYangFiles(parser, allInput); - SchemaContext resolveSchemaContext = parser.resolveSchemaContext(Sets - .newHashSet(allYangModules.values())); + SchemaContext resolveSchemaContext = YangParserWrapper.getSchemaContextFromModules(parser, allYangModules); // JMX generator @@ -115,7 +96,7 @@ public class MbeParser { public Map parseYangFilesToString( Collection allYangs) { - YangParserImpl parser = new YangParserImpl(); + YangParserImpl parser = YangParserWrapper.getYangParserInstance(); Map allYangModules = parser .parseYangModelsFromStreamsMapped(Lists.newArrayList(allYangs)); diff --git a/opendaylight/config/yang-store-impl/src/main/java/org/opendaylight/controller/config/yang/store/impl/YangParserWrapper.java b/opendaylight/config/yang-store-impl/src/main/java/org/opendaylight/controller/config/yang/store/impl/YangParserWrapper.java new file mode 100644 index 0000000000..7c428181aa --- /dev/null +++ b/opendaylight/config/yang-store-impl/src/main/java/org/opendaylight/controller/config/yang/store/impl/YangParserWrapper.java @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2013 Cisco Systems, Inc. and others. 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, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +package org.opendaylight.controller.config.yang.store.impl; + +import com.google.common.collect.Sets; +import org.apache.commons.io.IOUtils; +import org.opendaylight.controller.config.yang.store.api.YangStoreException; +import org.opendaylight.yangtools.yang.model.api.Module; +import org.opendaylight.yangtools.yang.model.api.SchemaContext; +import org.opendaylight.yangtools.yang.model.parser.api.YangModelParser; +import org.opendaylight.yangtools.yang.parser.impl.YangParserImpl; + +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import java.util.Map; + +public class YangParserWrapper { + + /** + * throw IllegalStateException if it is unable to parse yang files + */ + public static SchemaContext parseYangFiles(Collection yangFilesAsInputStreams) { + YangParserImpl parser = getYangParserInstance(); + Map mappedYangModules = null; + try { + mappedYangModules = parseYangFiles(parser, yangFilesAsInputStreams); + } catch (YangStoreException e) { + throw new IllegalStateException("Unable to parse yang files", e); + } + return getSchemaContextFromModules(parser, mappedYangModules); + } + + static YangParserImpl getYangParserInstance() { + return new YangParserImpl(); + } + + static SchemaContext getSchemaContextFromModules(YangModelParser parser, Map allYangModules) { + return parser.resolveSchemaContext(Sets + .newHashSet(allYangModules.values())); + } + + static Map parseYangFiles(YangModelParser parser, Collection allInput) throws YangStoreException { + List bufferedInputStreams = new ArrayList<>(); + for (InputStream is : allInput) { + String content; + try { + content = IOUtils.toString(is); + } catch (IOException e) { + throw new YangStoreException("Can not get yang as String from " + + is, e); + } + InputStream buf = new ByteArrayInputStream(content.getBytes()); + bufferedInputStreams.add(buf); + } + + return parser + .parseYangModelsFromStreamsMapped(bufferedInputStreams); + } +} diff --git a/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/ComponentActivator.xtend b/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/ComponentActivator.xtend index b460edff74..95acbcdb13 100644 --- a/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/ComponentActivator.xtend +++ b/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/ComponentActivator.xtend @@ -8,7 +8,6 @@ import static org.opendaylight.controller.sal.compatibility.NodeMapping.* import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey import org.apache.felix.dm.Component import java.util.Arrays -import org.opendaylight.yangtools.yang.binding.NotificationListener import java.util.Dictionary import java.util.Hashtable import org.opendaylight.controller.sal.utils.GlobalConstants @@ -30,6 +29,9 @@ import org.opendaylight.controller.sal.inventory.IPluginOutInventoryService import org.opendaylight.controller.sal.discovery.IDiscoveryService import org.opendaylight.controller.sal.topology.IPluginOutTopologyService import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev130819.FlowTopologyDiscoveryService +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.OpendaylightFlowTableStatisticsService +import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.OpendaylightPortStatisticsService +import org.opendaylight.controller.sal.binding.api.data.DataProviderService class ComponentActivator extends ComponentActivatorAbstractBase implements BindingAwareConsumer { @@ -44,9 +46,16 @@ class ComponentActivator extends ComponentActivatorAbstractBase implements Bindi @Property DataPacketAdapter dataPacket = new DataPacketAdapter; + @Property + org.opendaylight.controller.sal.utils.INodeFactory nodeFactory = new MDSalNodeFactory + + @Property + org.opendaylight.controller.sal.utils.INodeConnectorFactory nodeConnectorFactory = new MDSalNodeConnectorFactory + + override protected init() { - Node.NodeIDType.registerIDType(MD_SAL_TYPE, NodeKey); - NodeConnector.NodeConnectorIDType.registerIDType(MD_SAL_TYPE, NodeConnectorKey, MD_SAL_TYPE); + Node.NodeIDType.registerIDType(MD_SAL_TYPE, String); + NodeConnector.NodeConnectorIDType.registerIDType(MD_SAL_TYPE, String, MD_SAL_TYPE); } override start(BundleContext context) { @@ -71,25 +80,38 @@ class ComponentActivator extends ComponentActivatorAbstractBase implements Bindi // Inventory Service inventory.dataService = session.getSALService(DataBrokerService); inventory.flowStatisticsService = session.getRpcService(OpendaylightFlowStatisticsService); + inventory.flowTableStatisticsService = session.getRpcService(OpendaylightFlowTableStatisticsService); + inventory.nodeConnectorStatisticsService = session.getRpcService(OpendaylightPortStatisticsService); inventory.topologyDiscovery = session.getRpcService(FlowTopologyDiscoveryService); + inventory.dataProviderService = session.getSALService(DataProviderService) subscribe.registerNotificationListener(dataPacket) } override protected getGlobalImplementations() { - return Arrays.asList(this, flow, inventory, dataPacket) + return Arrays.asList(this, flow, inventory, dataPacket, nodeFactory, nodeConnectorFactory) } override protected configureGlobalInstance(Component c, Object imp) { configure(imp, c); } + private def dispatch configure(MDSalNodeFactory imp, Component it) { + setInterface(org.opendaylight.controller.sal.utils.INodeFactory.name, properties); + } + + private def dispatch configure(MDSalNodeConnectorFactory imp, Component it) { + setInterface(org.opendaylight.controller.sal.utils.INodeConnectorFactory.name, properties); + } + private def dispatch configure(ComponentActivator imp, Component it) { add( createServiceDependency().setService(BindingAwareBroker) // .setCallbacks("setBroker", "setBroker") // .setRequired(true)) + + } private def dispatch configure(DataPacketAdapter imp, Component it) { @@ -114,7 +136,7 @@ class ComponentActivator extends ComponentActivatorAbstractBase implements Bindi add( createServiceDependency() // .setService(IPluginOutReadService) // - .setCallbacks("setReadPublisher", "setReadPublisher") // + .setCallbacks("setReadPublisher", "unsetReadPublisher") // .setRequired(false)) add( createServiceDependency() // @@ -137,6 +159,7 @@ class ComponentActivator extends ComponentActivatorAbstractBase implements Bindi private def Dictionary properties() { val props = new Hashtable(); props.put(GlobalConstants.PROTOCOLPLUGINTYPE.toString, MD_SAL_TYPE) + props.put("protocolName", MD_SAL_TYPE); return props; } } diff --git a/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/FromSalConversionsUtils.java b/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/FromSalConversionsUtils.java index ad6009c827..4e6e49eac7 100644 --- a/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/FromSalConversionsUtils.java +++ b/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/FromSalConversionsUtils.java @@ -1,5 +1,9 @@ package org.opendaylight.controller.sal.compatibility; +import static org.opendaylight.controller.sal.compatibility.ProtocolConstants.CRUDP; +import static org.opendaylight.controller.sal.compatibility.ProtocolConstants.ETHERNET_ARP; +import static org.opendaylight.controller.sal.compatibility.ProtocolConstants.TCP; +import static org.opendaylight.controller.sal.compatibility.ProtocolConstants.UDP; import static org.opendaylight.controller.sal.match.MatchType.DL_DST; import static org.opendaylight.controller.sal.match.MatchType.DL_SRC; import static org.opendaylight.controller.sal.match.MatchType.DL_TYPE; @@ -8,11 +12,6 @@ import java.net.Inet4Address; import java.net.Inet6Address; import java.net.InetAddress; - -import org.opendaylight.controller.sal.core.NodeConnector; - - - import org.opendaylight.controller.sal.match.Match; import org.opendaylight.controller.sal.match.MatchField; import org.opendaylight.controller.sal.match.MatchType; @@ -22,14 +21,11 @@ import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types. import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv6Prefix; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress; -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetNodeConnectorStatisticsInput; -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetNodeConnectorStatisticsInputBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.address.Address; import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.address.address.Ipv4Builder; import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.address.address.Ipv6Builder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.MatchBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef; -import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef; import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.EtherType; import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId; import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanPcp; @@ -53,9 +49,8 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._4.match.TcpMatchBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._4.match.UdpMatchBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.vlan.match.fields.VlanIdBuilder; + import com.google.common.net.InetAddresses; -import static org.opendaylight.controller.sal.compatibility.NodeMapping.*; -import static org.opendaylight.controller.sal.compatibility.ProtocolConstants.*; public class FromSalConversionsUtils { @@ -63,19 +58,7 @@ public class FromSalConversionsUtils { } - public static GetNodeConnectorStatisticsInput nodeConnectorStatistics( - NodeConnector connector) { - GetNodeConnectorStatisticsInputBuilder target = new GetNodeConnectorStatisticsInputBuilder(); - - NodeRef nodeRef = toNodeRef(connector.getNode()); - target.setNode(nodeRef); - - NodeConnectorRef nodeConnectorRef = toNodeConnectorRef(connector); - target.setNodeConnector(nodeConnectorRef); - - return target.build(); - } - + @SuppressWarnings("unused") private static Address addressFromAction(InetAddress inetAddress) { String strInetAddresss = InetAddresses.toAddrString(inetAddress); if (inetAddress instanceof Inet4Address) { @@ -196,7 +179,7 @@ public class FromSalConversionsUtils { MatchField vlan = sourceMatch.getField(MatchType.DL_VLAN); if (vlan != null && vlan.getValue() != null) { VlanIdBuilder vlanIDBuilder = new VlanIdBuilder(); - vlanIDBuilder.setVlanId(new VlanId((int) (NetUtils + vlanIDBuilder.setVlanId(new VlanId((NetUtils .getUnsignedShort((short) vlan.getValue())))); vlanMatchBuild.setVlanId(vlanIDBuilder.build()); } @@ -270,7 +253,7 @@ public class FromSalConversionsUtils { InetAddress inetDestAddress = null; MatchField netDest = sourceMatch.getField(MatchType.NW_DST); - if (netSource != null && netSource.getValue() != null) { + if (netDest != null && netDest.getValue() != null) { inetDestAddress = (InetAddress) (netDest.getValue()); } @@ -371,5 +354,76 @@ public class FromSalConversionsUtils { .setIpv6Destination(new Ipv6Prefix(inetDstAddressString)); return layer6MatchBuild.build(); } + + public static boolean flowEquals(Flow statsFlow, Flow storedFlow) { + if (statsFlow.getClass() != storedFlow.getClass()) { + return false; + } + if (statsFlow.getBufferId()== null) { + if (storedFlow.getBufferId() != null) { + return false; + } + } else if(!statsFlow.getBufferId().equals(storedFlow.getBufferId())) { + return false; + } + if (statsFlow.getContainerName()== null) { + if (storedFlow.getContainerName()!= null) { + return false; + } + } else if(!statsFlow.getContainerName().equals(storedFlow.getContainerName())) { + return false; + } + if (statsFlow.getCookie()== null) { + if (storedFlow.getCookie()!= null) { + return false; + } + } else if(!statsFlow.getCookie().equals(storedFlow.getCookie())) { + return false; + } + if (statsFlow.getMatch()== null) { + if (storedFlow.getMatch() != null) { + return false; + } + } else if(!statsFlow.getMatch().equals(storedFlow.getMatch())) { + return false; + } + if (statsFlow.getCookie()== null) { + if (storedFlow.getCookie()!= null) { + return false; + } + } else if(!statsFlow.getCookie().equals(storedFlow.getCookie())) { + return false; + } + if (statsFlow.getHardTimeout() == null) { + if (storedFlow.getHardTimeout() != null) { + return false; + } + } else if(!statsFlow.getHardTimeout().equals(storedFlow.getHardTimeout() )) { + return false; + } + if (statsFlow.getIdleTimeout()== null) { + if (storedFlow.getIdleTimeout() != null) { + return false; + } + } else if(!statsFlow.getIdleTimeout().equals(storedFlow.getIdleTimeout())) { + return false; + } + if (statsFlow.getPriority() == null) { + if (storedFlow.getPriority() != null) { + return false; + } + } else if(!statsFlow.getPriority().equals(storedFlow.getPriority())) { + return false; + } + if (statsFlow.getTableId() == null) { + if (storedFlow.getTableId() != null) { + return false; + } + } else if(!statsFlow.getTableId().equals(storedFlow.getTableId())) { + return false; + } + return true; + } + } diff --git a/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/InventoryAndReadAdapter.xtend b/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/InventoryAndReadAdapter.xtend index 8ac6f1b050..31ae745d73 100644 --- a/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/InventoryAndReadAdapter.xtend +++ b/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/InventoryAndReadAdapter.xtend @@ -9,7 +9,6 @@ import org.opendaylight.controller.sal.binding.api.data.DataBrokerService import static extension org.opendaylight.controller.sal.common.util.Arguments.* import static extension org.opendaylight.controller.sal.compatibility.NodeMapping.* -import static org.opendaylight.controller.sal.compatibility.MDFlowMapping.* import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef @@ -19,9 +18,7 @@ import org.opendaylight.controller.sal.reader.NodeConnectorStatistics import org.opendaylight.controller.sal.reader.FlowOnNode import org.opendaylight.controller.sal.reader.NodeDescription import org.slf4j.LoggerFactory -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAllFlowStatisticsInputBuilder import java.util.ArrayList -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAllNodeConnectorStatisticsInputBuilder import org.opendaylight.controller.sal.inventory.IPluginInInventoryService import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.OpendaylightInventoryListener import org.opendaylight.controller.sal.inventory.IPluginOutInventoryService @@ -45,17 +42,64 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev130819.LinkUtilizationNormal import org.opendaylight.controller.sal.topology.TopoEdgeUpdate import org.opendaylight.controller.sal.discovery.IDiscoveryService - -class InventoryAndReadAdapter implements IPluginInTopologyService, IPluginInReadService, IPluginInInventoryService, OpendaylightInventoryListener, FlowTopologyDiscoveryListener { +import org.opendaylight.controller.sal.reader.IPluginOutReadService +import java.util.List +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.OpendaylightFlowStatisticsListener +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.OpendaylightFlowTableStatisticsListener +import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.OpendaylightPortStatisticsListener +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.AggregateFlowStatisticsUpdate +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.FlowsStatisticsUpdate +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.FlowTableStatisticsUpdate +import org.opendaylight.controller.sal.reader.NodeTableStatistics +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.flow.and.statistics.map.list.FlowAndStatisticsMapList +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAllFlowsStatisticsFromAllFlowTablesInputBuilder +import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.OpendaylightPortStatisticsService +import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.GetAllNodeConnectorsStatisticsInputBuilder +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.OpendaylightFlowTableStatisticsService +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey +import org.opendaylight.controller.sal.binding.api.data.DataProviderService +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.FlowStatisticsData +import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.FlowCapableNodeConnectorStatisticsData +import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.FlowCapableNodeConnectorStatistics +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.FlowTableStatisticsData +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.GetFlowTablesStatisticsInputBuilder +import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.GetNodeConnectorStatisticsInputBuilder +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId +import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.NodeConnectorStatisticsUpdate +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetFlowStatisticsFromFlowTableInputBuilder + +class InventoryAndReadAdapter implements IPluginInTopologyService, + IPluginInReadService, + IPluginInInventoryService, + OpendaylightInventoryListener, + FlowTopologyDiscoveryListener, + OpendaylightFlowStatisticsListener, + OpendaylightFlowTableStatisticsListener, + OpendaylightPortStatisticsListener { private static val LOG = LoggerFactory.getLogger(InventoryAndReadAdapter); + private static val OPENFLOWV10_TABLE_ID = new Integer(0).shortValue; @Property DataBrokerService dataService; + @Property + DataProviderService dataProviderService; + @Property OpendaylightFlowStatisticsService flowStatisticsService; + @Property + OpendaylightPortStatisticsService nodeConnectorStatisticsService; + + @Property + OpendaylightFlowTableStatisticsService flowTableStatisticsService; + @Property IPluginOutInventoryService inventoryPublisher; @@ -67,6 +111,22 @@ class InventoryAndReadAdapter implements IPluginInTopologyService, IPluginInRead @Property FlowTopologyDiscoveryService topologyDiscovery; + + @Property + List statisticsPublisher = new ArrayList(); + + def setReadPublisher(IPluginOutReadService listener) { + statisticsPublisher.add(listener); + } + + def unsetReadPublisher (IPluginOutReadService listener) { + if( listener != null) + statisticsPublisher.remove(listener); + } + + protected def startChange() { + return dataProviderService.beginTransaction; + } override getTransmitRate(NodeConnector connector) { val nodeConnector = readFlowCapableNodeConnector(connector.toNodeConnectorRef); @@ -74,82 +134,206 @@ class InventoryAndReadAdapter implements IPluginInTopologyService, IPluginInRead } override readAllFlow(Node node, boolean cached) { - val input = new GetAllFlowStatisticsInputBuilder; - input.setNode(node.toNodeRef); - val result = flowStatisticsService.getAllFlowStatistics(input.build) - val statistics = result.get.result; val output = new ArrayList(); - for (stat : statistics.flowStatistics) { - // FIXME: Create FlowOnNode - } + val tableRef = InstanceIdentifier.builder(Nodes) + .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node, InventoryMapping.toNodeKey(node)) + .augmentation(FlowCapableNode).child(Table, new TableKey(OPENFLOWV10_TABLE_ID)).toInstance(); + + val it = this.startChange(); + + val table= it.readConfigurationData(tableRef) as Table; + + if(table != null){ + LOG.info("Number of flows installed in table 0 of node {} : {}",node,table.flow.size); + + for(flow : table.flow){ + + val adsalFlow = ToSalConversionsUtils.toFlow(flow); + val statsFromDataStore = flow.getAugmentation(FlowStatisticsData) as FlowStatisticsData; + + if(statsFromDataStore != null){ + val it = new FlowOnNode(adsalFlow); + byteCount = statsFromDataStore.flowStatistics.byteCount.value.longValue; + packetCount = statsFromDataStore.flowStatistics.packetCount.value.longValue; + durationSeconds = statsFromDataStore.flowStatistics.duration.second.value.intValue; + durationNanoseconds = statsFromDataStore.flowStatistics.duration.nanosecond.value.intValue; + + output.add(it); + } + } + } + + //TODO (main): Shell we send request to the switch? It will make async request to the switch. + // Once plugin receive response, it will let adaptor know through onFlowStatisticsUpdate() + // If we assume that md-sal statistics manager will always be running, then its not required + // But if not, then sending request will collect the latest data for adaptor atleast. + val input = new GetAllFlowsStatisticsFromAllFlowTablesInputBuilder; + input.setNode(node.toNodeRef); + flowStatisticsService.getAllFlowsStatisticsFromAllFlowTables(input.build) + return output; } override readAllNodeConnector(Node node, boolean cached) { - val input = new GetAllNodeConnectorStatisticsInputBuilder(); + + val ret = new ArrayList(); + val nodeRef = InstanceIdentifier.builder(Nodes) + .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node, InventoryMapping.toNodeKey(node)) + .toInstance(); + + val provider = this.startChange(); + + val dsNode= provider.readConfigurationData(nodeRef) as org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node; + + if(dsNode != null){ + + for (dsNodeConnector : dsNode.nodeConnector){ + val nodeConnectorRef = InstanceIdentifier.builder(Nodes) + .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node, InventoryMapping.toNodeKey(node)) + .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector, dsNodeConnector.key) + .toInstance(); + + val nodeConnectorFromDS = provider.readConfigurationData(nodeConnectorRef) as org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector; + + if(nodeConnectorFromDS != null){ + val nodeConnectorStatsFromDs = nodeConnectorFromDS.getAugmentation(FlowCapableNodeConnectorStatisticsData) as FlowCapableNodeConnectorStatistics; + + ret.add(toNodeConnectorStatistics(nodeConnectorStatsFromDs.flowCapableNodeConnectorStatistics,dsNode.id,dsNodeConnector.id)); + } + } + } + + //TODO: Refer TODO (main) + val input = new GetAllNodeConnectorsStatisticsInputBuilder(); input.setNode(node.toNodeRef); - val result = flowStatisticsService.getAllNodeConnectorStatistics(input.build()); - val statistics = result.get.result.nodeConnectorStatistics; - val ret = new ArrayList(); - for (stat : statistics) { - ret.add(stat.toNodeConnectorStatistics()) - } + nodeConnectorStatisticsService.getAllNodeConnectorsStatistics(input.build()); return ret; } override readAllNodeTable(Node node, boolean cached) { - throw new UnsupportedOperationException("TODO: auto-generated method stub") + val ret = new ArrayList(); + + val dsFlowCapableNode= readFlowCapableNode(node.toNodeRef) + + if(dsFlowCapableNode != null){ + + for (table : dsFlowCapableNode.table){ + + val tableStats = table.getAugmentation(FlowTableStatisticsData) as FlowTableStatisticsData; + + if(tableStats != null){ + ret.add(toNodeTableStatistics(tableStats.flowTableStatistics,table.id,node)); + } + } + } + + //TODO: Refer TODO (main) + val input = new GetFlowTablesStatisticsInputBuilder(); + input.setNode(node.toNodeRef); + flowTableStatisticsService.getFlowTablesStatistics(input.build); + return ret; } override readDescription(Node node, boolean cached) { - val capableNode = readFlowCapableNode(node.toNodeRef) - - val it = new NodeDescription() - manufacturer = capableNode.manufacturer - serialNumber = capableNode.serialNumber - software = capableNode.software - description = capableNode.description - - return it; - } - - override readFlow(Node node, Flow flow, boolean cached) { - val input = flowStatisticsInput(node, flow); - val output = flowStatisticsService.getFlowStatistics(input); - - try { - val statistics = output.get().getResult(); - if (statistics != null) { - val it = new FlowOnNode(flow); - byteCount = statistics.byteCount.value.longValue - durationNanoseconds = statistics.duration.getNanosecond().getValue().intValue(); - durationSeconds = statistics.duration.getSecond().getValue().intValue(); - packetCount = statistics.getPacketCount().getValue().longValue(); - return it; - } - } catch (Exception e) { - LOG.error("Read flow not processed", e); - } - return null; + return toNodeDescription(node.toNodeRef); + } + + override readFlow(Node node, Flow targetFlow, boolean cached) { + var FlowOnNode ret= null; + + val tableRef = InstanceIdentifier.builder(Nodes) + .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node, InventoryMapping.toNodeKey(node)) + .augmentation(FlowCapableNode).child(Table, new TableKey(OPENFLOWV10_TABLE_ID)).toInstance(); + + val it = this.startChange(); + + val table= it.readConfigurationData(tableRef) as Table; + + if(table != null){ + LOG.info("Number of flows installed in table 0 of node {} : {}",node,table.flow.size); + + for(mdsalFlow : table.flow){ + if(FromSalConversionsUtils.flowEquals(mdsalFlow, MDFlowMapping.toMDSalflow(targetFlow))){ + val statsFromDataStore = mdsalFlow.getAugmentation(FlowStatisticsData) as FlowStatisticsData; + + if(statsFromDataStore != null){ + LOG.debug("Found matching flow in the data store flow table "); + val it = new FlowOnNode(targetFlow); + byteCount = statsFromDataStore.flowStatistics.byteCount.value.longValue; + packetCount = statsFromDataStore.flowStatistics.packetCount.value.longValue; + durationSeconds = statsFromDataStore.flowStatistics.duration.second.value.intValue; + durationNanoseconds = statsFromDataStore.flowStatistics.duration.nanosecond.value.intValue; + + ret = it; + } + } + } + } + + //TODO: Refer TODO (main) + val input = new GetFlowStatisticsFromFlowTableInputBuilder; + input.setNode(node.toNodeRef); + input.fieldsFrom(MDFlowMapping.toMDSalflow(targetFlow)); + flowStatisticsService.getFlowStatisticsFromFlowTable(input.build) + + return ret; + } override readNodeConnector(NodeConnector connector, boolean cached) { + var NodeConnectorStatistics nodeConnectorStatistics = null; + + val nodeConnectorRef = InstanceIdentifier.builder(Nodes) + .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node, InventoryMapping.toNodeKey(connector.node)) + .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector, InventoryMapping.toNodeConnectorKey(connector)) + .toInstance(); + val provider = this.startChange(); + + val nodeConnectorFromDS = provider.readConfigurationData(nodeConnectorRef) as org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector; + + if(nodeConnectorFromDS != null){ + val nodeConnectorStatsFromDs = nodeConnectorFromDS.getAugmentation(FlowCapableNodeConnectorStatisticsData) as FlowCapableNodeConnectorStatistics; + if(nodeConnectorStatsFromDs != null) { + nodeConnectorStatistics = toNodeConnectorStatistics(nodeConnectorStatsFromDs.flowCapableNodeConnectorStatistics, + InventoryMapping.toNodeKey(connector.node).id, + InventoryMapping.toNodeConnectorKey(connector).id); + } + } + + //TODO: Refer TODO (main) + val input = new GetNodeConnectorStatisticsInputBuilder(); + input.setNode(connector.node.toNodeRef); + input.setNodeConnectorId(InventoryMapping.toNodeConnectorKey(connector).id); + nodeConnectorStatisticsService.getNodeConnectorStatistics(input.build()); + return nodeConnectorStatistics; + } - val getNodeConnectorStatisticsInput = FromSalConversionsUtils.nodeConnectorStatistics(connector); - val future = flowStatisticsService.getNodeConnectorStatistics(getNodeConnectorStatisticsInput); - try { - val rpcResult = future.get(); - val output = rpcResult.getResult(); - - if (output != null) { - return output.toNodeConnectorStatistics; - } - } catch (Exception e) { - LOG.error("Read node connector not processed", e); - } - - return null; + override readNodeTable(NodeTable nodeTable, boolean cached) { + var NodeTableStatistics nodeStats = null + + val tableRef = InstanceIdentifier.builder(Nodes) + .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node, InventoryMapping.toNodeKey(nodeTable.node)) + .augmentation(FlowCapableNode).child(Table, new TableKey(nodeTable.ID as Short)).toInstance(); + + val it = this.startChange(); + + val table= it.readConfigurationData(tableRef) as Table; + + if(table != null){ + val tableStats = table.getAugmentation(FlowTableStatisticsData) as FlowTableStatisticsData; + + if(tableStats != null){ + nodeStats = toNodeTableStatistics(tableStats.flowTableStatistics,table.id,nodeTable.node); + } + } + + //TODO: Refer TODO (main) + val input = new GetFlowTablesStatisticsInputBuilder(); + input.setNode(nodeTable.node.toNodeRef); + flowTableStatisticsService.getFlowTablesStatistics(input.build); + + return nodeStats; } override onNodeConnectorRemoved(NodeConnectorRemoved update) { @@ -157,17 +341,45 @@ class InventoryAndReadAdapter implements IPluginInTopologyService, IPluginInRead } override onNodeRemoved(NodeRemoved notification) { - // NOOP + val properties = Collections.emptySet(); + + inventoryPublisher.updateNode(notification.nodeRef.toADNode, UpdateType.REMOVED, properties); } override onNodeConnectorUpdated(NodeConnectorUpdated update) { - val properties = Collections.emptySet(); - inventoryPublisher.updateNodeConnector(update.nodeConnectorRef.toADNodeConnector, UpdateType.CHANGED, properties); + val properties = new java.util.HashSet(); + + + val org.opendaylight.yangtools.yang.binding.InstanceIdentifier identifier = update.nodeConnectorRef.value as org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + var updateType = UpdateType.CHANGED; + if ( this._dataService.readOperationalData(identifier) == null ){ + updateType = UpdateType.ADDED; + } + + var nodeConnector = update.nodeConnectorRef.toADNodeConnector + + + properties.add(new org.opendaylight.controller.sal.core.Name(nodeConnector.ID.toString())); + + inventoryPublisher.updateNodeConnector(nodeConnector , updateType , properties); } override onNodeUpdated(NodeUpdated notification) { val properties = Collections.emptySet(); - inventoryPublisher.updateNode(notification.nodeRef.toADNode, UpdateType.CHANGED, properties); + val org.opendaylight.yangtools.yang.binding.InstanceIdentifier identifier = notification.nodeRef.value as org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + + var updateType = UpdateType.CHANGED; + if ( this._dataService.readOperationalData(identifier) == null ){ + updateType = UpdateType.ADDED; + } + inventoryPublisher.updateNode(notification.nodeRef.toADNode, updateType, properties); + + //Notify the listeners of IPluginOutReadService + + for (statsPublisher : statisticsPublisher){ + val nodeRef = InstanceIdentifier.builder(Nodes).child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node,new NodeKey(notification.id)).toInstance; + statsPublisher.descriptionStatisticsUpdated(nodeRef.toADNode,toNodeDescription(notification.nodeRef)); + } } override getNodeProps() { @@ -182,10 +394,6 @@ class InventoryAndReadAdapter implements IPluginInTopologyService, IPluginInRead return null; } - override readNodeTable(NodeTable table, boolean cached) { - throw new UnsupportedOperationException("TODO: auto-generated method stub") - } - private def FlowCapableNode readFlowCapableNode(NodeRef ref) { val dataObject = dataService.readOperationalData(ref.value as InstanceIdentifier); val node = dataObject.checkInstanceOf( @@ -200,26 +408,61 @@ class InventoryAndReadAdapter implements IPluginInTopologyService, IPluginInRead return node.getAugmentation(FlowCapableNodeConnector); } - private static def toNodeConnectorStatistics( - org.opendaylight.yang.gen.v1.urn.opendaylight.model.statistics.types.rev130925.NodeConnectorStatistics output) { - val it = new NodeConnectorStatistics - - collisionCount = output.getCollisionCount().longValue(); - receiveCRCErrorCount = output.getReceiveCrcError().longValue(); - receiveFrameErrorCount = output.getReceiveFrameError().longValue(); - receiveOverRunErrorCount = output.getReceiveOverRunError().longValue(); + private def toNodeConnectorStatistics( + org.opendaylight.yang.gen.v1.urn.opendaylight.model.statistics.types.rev130925.NodeConnectorStatistics nodeConnectorStatistics, NodeId nodeId, NodeConnectorId nodeConnectorId) { + + val it = new NodeConnectorStatistics(); + + receivePacketCount = nodeConnectorStatistics.packets.received.longValue; + transmitPacketCount = nodeConnectorStatistics.packets.transmitted.longValue; + + receiveByteCount = nodeConnectorStatistics.bytes.received.longValue; + transmitByteCount = nodeConnectorStatistics.bytes.transmitted.longValue; + + receiveDropCount = nodeConnectorStatistics.receiveDrops.longValue; + transmitDropCount = nodeConnectorStatistics.transmitDrops.longValue; + + receiveErrorCount = nodeConnectorStatistics.receiveErrors.longValue; + transmitErrorCount = nodeConnectorStatistics.transmitErrors.longValue; + + receiveFrameErrorCount = nodeConnectorStatistics.receiveFrameError.longValue; + receiveOverRunErrorCount = nodeConnectorStatistics.receiveOverRunError.longValue; + receiveCRCErrorCount = nodeConnectorStatistics.receiveCrcError.longValue; + collisionCount = nodeConnectorStatistics.collisionCount.longValue; + + val nodeConnectorRef = InstanceIdentifier.builder(Nodes) + .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node,new NodeKey(nodeId)) + .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector,new NodeConnectorKey(nodeConnectorId)).toInstance; + + nodeConnector = NodeMapping.toADNodeConnector(new NodeConnectorRef(nodeConnectorRef)); + + return it; + } - receiveDropCount = output.getReceiveDrops().longValue(); - receiveErrorCount = output.getReceiveErrors().longValue(); - receivePacketCount = output.getPackets().getReceived().longValue(); - receiveByteCount = output.getBytes().getReceived().longValue(); + private def toNodeTableStatistics( + org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.flow.table.statistics.FlowTableStatistics tableStats, + Short tableId,Node node){ + var it = new NodeTableStatistics(); + + activeCount = tableStats.activeFlows.value.intValue; + lookupCount = tableStats.packetsLookedUp.value.intValue; + matchedCount = tableStats.packetsMatched.value.intValue; + name = tableId.toString; + nodeTable = new NodeTable(NodeMapping.MD_SAL_TYPE,tableId,node); + return it; + } + + private def toNodeDescription(NodeRef nodeRef){ + val capableNode = readFlowCapableNode(nodeRef); - transmitDropCount = output.getTransmitDrops().longValue(); - transmitErrorCount = output.getTransmitErrors().longValue(); - transmitPacketCount = output.getPackets().getTransmitted().longValue(); - transmitByteCount = output.getBytes().getTransmitted().longValue(); + val it = new NodeDescription() + manufacturer = capableNode.manufacturer + serialNumber = capableNode.serialNumber + software = capableNode.software + description = capableNode.description + return it; - } + } override sollicitRefresh() { topologyDiscovery.solicitRefresh @@ -248,5 +491,78 @@ class InventoryAndReadAdapter implements IPluginInTopologyService, IPluginInRead def Edge toADEdge(Link link) { new Edge(link.source.toADNodeConnector,link.destination.toADNodeConnector) } - + + /* + * OpendaylightFlowStatisticsListener interface implementation + */ + override onAggregateFlowStatisticsUpdate(AggregateFlowStatisticsUpdate notification) { + throw new UnsupportedOperationException("TODO: auto-generated method stub") + } + + override onFlowsStatisticsUpdate(FlowsStatisticsUpdate notification) { + + val adsalFlowsStatistics = new ArrayList(); + + for(flowStats : notification.flowAndStatisticsMapList){ + if(flowStats.tableId == 0) + adsalFlowsStatistics.add(toFlowOnNode(flowStats)); + } + + for (statsPublisher : statisticsPublisher){ + val nodeRef = InstanceIdentifier.builder(Nodes).child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node,new NodeKey(notification.id)).toInstance; + statsPublisher.nodeFlowStatisticsUpdated(nodeRef.toADNode,adsalFlowsStatistics); + } + + } + /* + * OpendaylightFlowTableStatisticsListener interface implementation + */ + override onFlowTableStatisticsUpdate(FlowTableStatisticsUpdate notification) { + var adsalFlowTableStatistics = new ArrayList(); + + for(stats : notification.flowTableAndStatisticsMap){ + if (stats.tableId.value == 0){ + val it = new NodeTableStatistics(); + activeCount = stats.activeFlows.value.intValue; + lookupCount = stats.packetsLookedUp.value.longValue; + matchedCount = stats.packetsMatched.value.longValue; + + adsalFlowTableStatistics.add(it); + } + } + for (statsPublisher : statisticsPublisher){ + val nodeRef = InstanceIdentifier.builder(Nodes).child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node,new NodeKey(notification.id)).toInstance; + statsPublisher.nodeTableStatisticsUpdated(nodeRef.toADNode,adsalFlowTableStatistics); + } + } + + /* + * OpendaylightPortStatisticsUpdate interface implementation + */ + override onNodeConnectorStatisticsUpdate(NodeConnectorStatisticsUpdate notification) { + + val adsalPortStatistics = new ArrayList(); + + for(nodeConnectorStatistics : notification.nodeConnectorStatisticsAndPortNumberMap){ + adsalPortStatistics.add(toNodeConnectorStatistics(nodeConnectorStatistics,notification.id,nodeConnectorStatistics.nodeConnectorId)); + } + + for (statsPublisher : statisticsPublisher){ + val nodeRef = InstanceIdentifier.builder(Nodes).child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node,new NodeKey(notification.id)).toInstance; + statsPublisher.nodeConnectorStatisticsUpdated(nodeRef.toADNode,adsalPortStatistics); + } + + } + + private static def toFlowOnNode (FlowAndStatisticsMapList flowAndStatsMap){ + + val it = new FlowOnNode(ToSalConversionsUtils.toFlow(flowAndStatsMap)); + + byteCount = flowAndStatsMap.byteCount.value.longValue; + packetCount = flowAndStatsMap.packetCount.value.longValue; + durationSeconds = flowAndStatsMap.duration.second.value.intValue; + durationNanoseconds = flowAndStatsMap.duration.nanosecond.value.intValue; + + return it; + } } diff --git a/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/MDFlowMapping.xtend b/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/MDFlowMapping.xtend index 6cf728cde9..2f458c41dd 100644 --- a/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/MDFlowMapping.xtend +++ b/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/MDFlowMapping.xtend @@ -5,7 +5,6 @@ import java.math.BigInteger import java.net.Inet4Address import java.net.Inet6Address import java.util.ArrayList -import java.util.List import org.opendaylight.controller.sal.action.Controller import org.opendaylight.controller.sal.action.Drop import org.opendaylight.controller.sal.action.Flood @@ -40,7 +39,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.AddF import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.FlowAddedBuilder import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.RemoveFlowInputBuilder import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.UpdateFlowInputBuilder -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetFlowStatisticsInputBuilder import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.VlanCfi import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.address.Address import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.address.address.Ipv4Builder @@ -67,7 +65,6 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.acti import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.hw.path.action._case.HwPathActionBuilder import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.loopback.action._case.LoopbackActionBuilder import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.output.action._case.OutputActionBuilder -import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.pop.vlan.action._case.PopVlanActionBuilder import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.push.vlan.action._case.PushVlanActionBuilder import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.dl.dst.action._case.SetDlDstActionBuilder import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.set.dl.src.action._case.SetDlSrcActionBuilder @@ -106,6 +103,8 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.acti import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.SwPathActionCaseBuilder import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.apply.actions._case.ApplyActionsBuilder import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.instruction.instruction.ApplyActionsCaseBuilder +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder public class MDFlowMapping { @@ -142,13 +141,6 @@ public class MDFlowMapping { return it.build; } - public static def flowStatisticsInput(Node sourceNode, Flow sourceFlow) { - val source = flowAdded(sourceFlow); - val it = new GetFlowStatisticsInputBuilder(source as org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.Flow); - node = sourceNode.toNodeRef(); - return it.build(); - } - public static def removeFlowInput(Node sourceNode, Flow sourceFlow) { val source = flowAdded(sourceFlow); val it = new RemoveFlowInputBuilder(source as org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.Flow); @@ -355,7 +347,7 @@ public class MDFlowMapping { } public static def Uri toUri(NodeConnector connector) { - throw new UnsupportedOperationException("TODO: auto-generated method stub") + return new NodeConnectorId(connector.ID as String); } public static def MacAddress toMacAddress(byte[] bytes) { @@ -367,4 +359,25 @@ public class MDFlowMapping { } return new MacAddress(sb.toString()); } + + public static def toMDSalflow(Flow sourceFlow) { + if (sourceFlow == null) + throw new IllegalArgumentException(); + val it = new FlowBuilder(); + + hardTimeout = sourceFlow.hardTimeout as int + idleTimeout = sourceFlow.idleTimeout as int + cookie = BigInteger.valueOf(sourceFlow.id) + priority = sourceFlow.priority as int + + val sourceActions = sourceFlow.actions; + val targetActions = new ArrayList(); + for (sourceAction : sourceActions) { + targetActions.add(sourceAction.toAction()); + } + instructions = targetActions.toApplyInstruction(); + match = sourceFlow.match.toMatch(); + return it.build(); + } + } diff --git a/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/MDSalNodeConnectorFactory.java b/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/MDSalNodeConnectorFactory.java new file mode 100644 index 0000000000..5b4b16a39a --- /dev/null +++ b/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/MDSalNodeConnectorFactory.java @@ -0,0 +1,23 @@ +package org.opendaylight.controller.sal.compatibility; + +import org.opendaylight.controller.sal.core.ConstructionException; +import org.opendaylight.controller.sal.core.Node; +import org.opendaylight.controller.sal.core.NodeConnector; +import org.opendaylight.controller.sal.utils.INodeConnectorFactory; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class MDSalNodeConnectorFactory implements INodeConnectorFactory{ + private Logger logger = LoggerFactory.getLogger(MDSalNodeConnectorFactory.class); + + @Override + public NodeConnector fromStringNoNode(String type, String id, Node node) { + try { + return new NodeConnector(type, id, node); + } catch (ConstructionException e) { + logger.error("Could not construct NodeConnector", e); + } + return null; + + } +} diff --git a/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/MDSalNodeFactory.java b/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/MDSalNodeFactory.java new file mode 100644 index 0000000000..e36ebd7245 --- /dev/null +++ b/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/MDSalNodeFactory.java @@ -0,0 +1,22 @@ +package org.opendaylight.controller.sal.compatibility; + +import org.opendaylight.controller.sal.core.ConstructionException; +import org.opendaylight.controller.sal.core.Node; +import org.opendaylight.controller.sal.utils.INodeFactory; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class MDSalNodeFactory implements INodeFactory{ + private Logger logger = LoggerFactory.getLogger(MDSalNodeFactory.class); + + @Override + public Node fromString(String type, String id) { + + try { + return new Node(type, id); + } catch (ConstructionException e) { + logger.error("Could not construct Node", e); + } + return null; + } +} diff --git a/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/NodeMapping.xtend b/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/NodeMapping.xtend index 4c9a9e6658..6bfee578ab 100644 --- a/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/NodeMapping.xtend +++ b/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/NodeMapping.xtend @@ -10,17 +10,19 @@ import static extension org.opendaylight.controller.sal.common.util.Arguments.*; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey import org.opendaylight.controller.sal.core.ConstructionException import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes +import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId + public class NodeMapping { public static val MD_SAL_TYPE = "MD_SAL"; private static val NODE_CLASS = org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node; - private static val NODECONNECTOR_CLASS = org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node. - NodeConnector; + private static val NODECONNECTOR_CLASS = org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector; private new() { throw new UnsupportedOperationException("Utility class. Instantiation is not allowed."); @@ -33,7 +35,7 @@ public class NodeMapping { val arg = node.getPath().get(1); val item = arg.checkInstanceOf(IdentifiableItem); val nodeKey = item.getKey().checkInstanceOf(NodeKey); - return new Node(MD_SAL_TYPE, nodeKey); + return new Node(MD_SAL_TYPE, nodeKey.getId().getValue().toString()); } public static def toADNodeConnector(NodeConnectorRef source) throws ConstructionException { @@ -44,20 +46,22 @@ public class NodeMapping { val arg = path.getPath().get(2); val item = arg.checkInstanceOf(IdentifiableItem); val connectorKey = item.getKey().checkInstanceOf(NodeConnectorKey); - return new NodeConnector(MD_SAL_TYPE, connectorKey, node); + return new NodeConnector(MD_SAL_TYPE, connectorKey.getId().getValue().toString(), node); } - + public static def toNodeRef(Node node) { checkArgument(MD_SAL_TYPE.equals(node.getType())); - val nodeKey = node.ID.checkInstanceOf(NodeKey); + var nodeId = node.ID.checkInstanceOf(String) + val nodeKey = new NodeKey(new NodeId(nodeId)); val nodePath = InstanceIdentifier.builder().node(Nodes).child(NODE_CLASS, nodeKey).toInstance(); return new NodeRef(nodePath); } - + public static def toNodeConnectorRef(NodeConnector nodeConnector) { val node = nodeConnector.node.toNodeRef(); val nodePath = node.getValue() as InstanceIdentifier - val connectorKey = nodeConnector.ID.checkInstanceOf(NodeConnectorKey); + var nodeConnectorId = nodeConnector.ID.checkInstanceOf(String) + val connectorKey = new NodeConnectorKey(new NodeConnectorId(nodeConnectorId)); val path = InstanceIdentifier.builder(nodePath).child(NODECONNECTOR_CLASS, connectorKey).toInstance(); return new NodeConnectorRef(path); } @@ -65,5 +69,5 @@ public class NodeMapping { public static def toADNode(NodeRef node) throws ConstructionException { return toADNode(node.getValue()); } - + } diff --git a/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/ToSalConversionsUtils.java b/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/ToSalConversionsUtils.java index a8349be1b4..37bb277858 100644 --- a/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/ToSalConversionsUtils.java +++ b/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/ToSalConversionsUtils.java @@ -1,6 +1,25 @@ package org.opendaylight.controller.sal.compatibility; -import com.google.common.net.InetAddresses; +import static org.opendaylight.controller.sal.compatibility.ProtocolConstants.CRUDP; +import static org.opendaylight.controller.sal.compatibility.ProtocolConstants.ETHERNET_ARP; +import static org.opendaylight.controller.sal.compatibility.ProtocolConstants.TCP; +import static org.opendaylight.controller.sal.compatibility.ProtocolConstants.UDP; +import static org.opendaylight.controller.sal.match.MatchType.DL_DST; +import static org.opendaylight.controller.sal.match.MatchType.DL_SRC; +import static org.opendaylight.controller.sal.match.MatchType.DL_TYPE; +import static org.opendaylight.controller.sal.match.MatchType.DL_VLAN; +import static org.opendaylight.controller.sal.match.MatchType.DL_VLAN_PR; +import static org.opendaylight.controller.sal.match.MatchType.NW_DST; +import static org.opendaylight.controller.sal.match.MatchType.NW_PROTO; +import static org.opendaylight.controller.sal.match.MatchType.NW_SRC; +import static org.opendaylight.controller.sal.match.MatchType.NW_TOS; +import static org.opendaylight.controller.sal.match.MatchType.TP_DST; +import static org.opendaylight.controller.sal.match.MatchType.TP_SRC; + +import java.net.InetAddress; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; import org.opendaylight.controller.sal.action.Controller; import org.opendaylight.controller.sal.action.Drop; @@ -33,7 +52,6 @@ import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types. import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Uri; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress; -import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.ActionList; import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.VlanCfi; import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.ControllerActionCase; import org.opendaylight.yang.gen.v1.urn.opendaylight.action.types.rev131112.action.action.DropActionCase; @@ -88,26 +106,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.match.layer._4.match.UdpMatch; import org.opendaylight.yang.gen.v1.urn.opendaylight.model.match.types.rev131026.vlan.match.fields.VlanId; -import java.net.InetAddress; -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; - -import static org.opendaylight.controller.sal.compatibility.ProtocolConstants.ETHERNET_ARP; -import static org.opendaylight.controller.sal.compatibility.ProtocolConstants.CRUDP; -import static org.opendaylight.controller.sal.compatibility.ProtocolConstants.TCP; -import static org.opendaylight.controller.sal.compatibility.ProtocolConstants.UDP; -import static org.opendaylight.controller.sal.match.MatchType.DL_DST; -import static org.opendaylight.controller.sal.match.MatchType.DL_SRC; -import static org.opendaylight.controller.sal.match.MatchType.DL_TYPE; -import static org.opendaylight.controller.sal.match.MatchType.DL_VLAN; -import static org.opendaylight.controller.sal.match.MatchType.DL_VLAN_PR; -import static org.opendaylight.controller.sal.match.MatchType.NW_DST; -import static org.opendaylight.controller.sal.match.MatchType.NW_PROTO; -import static org.opendaylight.controller.sal.match.MatchType.NW_SRC; -import static org.opendaylight.controller.sal.match.MatchType.NW_TOS; -import static org.opendaylight.controller.sal.match.MatchType.TP_DST; -import static org.opendaylight.controller.sal.match.MatchType.TP_SRC; +import com.google.common.net.InetAddresses; public class ToSalConversionsUtils { @@ -484,11 +483,11 @@ public class ToSalConversionsUtils { private static void fillFromArp(Match target, ArpMatch source) { Ipv4Prefix sourceAddress = source.getArpSourceTransportAddress(); if (sourceAddress != null) { - target.setField(NW_SRC, (InetAddress) inetAddressFrom(sourceAddress), null); + target.setField(NW_SRC, inetAddressFrom(sourceAddress), null); } Ipv4Prefix destAddress = source.getArpTargetTransportAddress(); if (destAddress != null) { - target.setField(NW_DST, (InetAddress) inetAddressFrom(destAddress), null); + target.setField(NW_DST, inetAddressFrom(destAddress), null); } ArpSourceHardwareAddress sourceHwAddress = source.getArpSourceHardwareAddress(); if (sourceHwAddress != null) { @@ -506,22 +505,22 @@ public class ToSalConversionsUtils { private static void fillFromIpv6(Match target, Ipv6Match source) { Ipv6Prefix sourceAddress = source.getIpv6Source(); if (sourceAddress != null) { - target.setField(NW_SRC, (InetAddress) inetAddressFrom(sourceAddress), null); + target.setField(NW_SRC, inetAddressFrom(sourceAddress), null); } Ipv6Prefix destAddress = source.getIpv6Destination(); if (destAddress != null) { - target.setField(NW_DST, (InetAddress) inetAddressFrom(destAddress), null); + target.setField(NW_DST, inetAddressFrom(destAddress), null); } } private static void fillFromIpv4(Match target, Ipv4Match source) { Ipv4Prefix sourceAddress = source.getIpv4Source(); if (sourceAddress != null) { - target.setField(NW_SRC, (InetAddress) inetAddressFrom(sourceAddress), null); + target.setField(NW_SRC, inetAddressFrom(sourceAddress), null); } Ipv4Prefix destAddress = source.getIpv4Destination(); if (destAddress != null) { - target.setField(NW_DST, (InetAddress) inetAddressFrom(destAddress), null); + target.setField(NW_DST, inetAddressFrom(destAddress), null); } } diff --git a/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/adsal/FlowStatisticsAdapter.java b/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/adsal/FlowStatisticsAdapter.java index 09585d6273..149544b6c4 100644 --- a/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/adsal/FlowStatisticsAdapter.java +++ b/opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/adsal/FlowStatisticsAdapter.java @@ -8,6 +8,8 @@ import java.util.concurrent.Future; import org.opendaylight.controller.sal.binding.api.NotificationProviderService; import org.opendaylight.controller.sal.common.util.Futures; import org.opendaylight.controller.sal.common.util.Rpcs; +import org.opendaylight.controller.sal.compatibility.FromSalConversionsUtils; +import org.opendaylight.controller.sal.compatibility.InventoryMapping; import org.opendaylight.controller.sal.compatibility.NodeMapping; import org.opendaylight.controller.sal.compatibility.ToSalConversionsUtils; import org.opendaylight.controller.sal.core.ConstructionException; @@ -19,87 +21,78 @@ import org.opendaylight.controller.sal.reader.IReadServiceListener; import org.opendaylight.controller.sal.reader.NodeConnectorStatistics; import org.opendaylight.controller.sal.reader.NodeDescription; import org.opendaylight.controller.sal.reader.NodeTableStatistics; +import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.Counter32; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.Counter64; -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.FlowStatisticsUpdatedBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.FlowsStatisticsUpdateBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAggregateFlowStatisticsFromFlowTableForAllFlowsInput; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAggregateFlowStatisticsFromFlowTableForAllFlowsOutput; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAggregateFlowStatisticsFromFlowTableForGivenMatchInput; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAggregateFlowStatisticsFromFlowTableForGivenMatchOutput; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAllFlowStatisticsFromFlowTableInput; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAllFlowStatisticsFromFlowTableOutput; -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAllFlowStatisticsInput; -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAllFlowStatisticsOutput; -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAllFlowStatisticsOutputBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAllFlowStatisticsFromFlowTableOutputBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAllFlowsStatisticsFromAllFlowTablesInput; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAllFlowsStatisticsFromAllFlowTablesOutput; -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAllNodeConnectorStatisticsInput; -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAllNodeConnectorStatisticsOutput; -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAllNodeConnectorStatisticsOutputBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAllFlowsStatisticsFromAllFlowTablesOutputBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetFlowStatisticsFromFlowTableInput; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetFlowStatisticsFromFlowTableOutput; -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetFlowStatisticsInput; -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetFlowStatisticsOutput; -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetFlowStatisticsOutputBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetFlowTableStatisticsInput; -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetFlowTableStatisticsOutput; -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetFlowTableStatisticsOutputBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetNodeConnectorStatisticsInput; -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetNodeConnectorStatisticsOutput; -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetNodeConnectorStatisticsOutputBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.NodeConnectorStatisticsUpdatedBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetFlowStatisticsFromFlowTableOutputBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.OpendaylightFlowStatisticsService; -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.get.all.flow.statistics.output.FlowStatistics; -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.get.all.flow.statistics.output.FlowStatisticsBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.get.all.node.connector.statistics.output.NodeConnectorStatisticsBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.statistics.Duration; -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.statistics.DurationBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.flow.and.statistics.map.list.FlowAndStatisticsMapList; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.flow.and.statistics.map.list.FlowAndStatisticsMapListBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.FlowTableStatisticsUpdateBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.flow.table.and.statistics.map.FlowTableAndStatisticsMap; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.flow.table.and.statistics.map.FlowTableAndStatisticsMapBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev131103.TransactionId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.model.statistics.types.rev130925.duration.DurationBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.model.statistics.types.rev130925.node.connector.statistics.Bytes; import org.opendaylight.yang.gen.v1.urn.opendaylight.model.statistics.types.rev130925.node.connector.statistics.BytesBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.model.statistics.types.rev130925.node.connector.statistics.Packets; import org.opendaylight.yang.gen.v1.urn.opendaylight.model.statistics.types.rev130925.node.connector.statistics.PacketsBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.NodeConnectorStatisticsUpdateBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.node.connector.statistics.and.port.number.map.NodeConnectorStatisticsAndPortNumberMap; +import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.node.connector.statistics.and.port.number.map.NodeConnectorStatisticsAndPortNumberMapBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.table.types.rev131026.TableId; import org.opendaylight.yangtools.yang.common.RpcResult; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -public class FlowStatisticsAdapter implements OpendaylightFlowStatisticsService, IReadServiceListener { +public class FlowStatisticsAdapter implements OpendaylightFlowStatisticsService, IReadServiceListener{ private static final Logger LOG = LoggerFactory.getLogger(FlowStatisticsAdapter.class); private IReadService readDelegate; private NotificationProviderService notifier; @Override - public Future> getAllFlowStatistics(GetAllFlowStatisticsInput input) { - GetAllFlowStatisticsOutput rpcResultType = null; - boolean rpcResultBool = false; - - try { - Node adNode = NodeMapping.toADNode(input.getNode()); - List flowsOnNode = readDelegate.readAllFlows(adNode); - List flowsStatistics = toOdFlowsStatistics(flowsOnNode); - GetAllFlowStatisticsOutputBuilder builder = new GetAllFlowStatisticsOutputBuilder(); - rpcResultType = builder.setFlowStatistics(flowsStatistics).build(); - rpcResultBool = true; - } catch (ConstructionException e) { - LOG.error(e.getMessage()); - } + public Future> getAggregateFlowStatisticsFromFlowTableForAllFlows( + GetAggregateFlowStatisticsFromFlowTableForAllFlowsInput input) { + //TODO: No supported API exist in AD-SAL, it can either be implemented by fetching all the stats of the flows and + // generating aggregate flow statistics out of those individual flow stats. + return null; + } - return Futures.immediateFuture(Rpcs.getRpcResult(rpcResultBool, rpcResultType, null)); + @Override + public Future> getAggregateFlowStatisticsFromFlowTableForGivenMatch( + GetAggregateFlowStatisticsFromFlowTableForGivenMatchInput input) { + //TODO: No supported API exist in AD-SAL, it can either be implemented by fetching all the stats of the flows and + // generating aggregate flow statistics out of those individual flow stats. + return null; } @Override - public Future> getAllNodeConnectorStatistics( - GetAllNodeConnectorStatisticsInput input) { - GetAllNodeConnectorStatisticsOutput rpcResultType = null; + public Future> getAllFlowStatisticsFromFlowTable( + GetAllFlowStatisticsFromFlowTableInput input) { + GetAllFlowStatisticsFromFlowTableOutput rpcResultType = null; boolean rpcResultBool = false; try { Node adNode = NodeMapping.toADNode(input.getNode()); - List nodesConnectorStatistics = readDelegate.readNodeConnectors(adNode); - List odNodesConnectorStatistics; - odNodesConnectorStatistics = toOdNodesConnectorStatistics(nodesConnectorStatistics); - GetAllNodeConnectorStatisticsOutputBuilder builder = new GetAllNodeConnectorStatisticsOutputBuilder(); - rpcResultType = builder.setNodeConnectorStatistics(odNodesConnectorStatistics).build(); + List flowsOnNode = readDelegate.readAllFlows(adNode); + List flowsStatistics = toOdFlowsStatistics(flowsOnNode); + GetAllFlowStatisticsFromFlowTableOutputBuilder builder = new GetAllFlowStatisticsFromFlowTableOutputBuilder(); + builder.setTransactionId(new TransactionId(new BigInteger("0"))); + rpcResultType = builder.setFlowAndStatisticsMapList(flowsStatistics).build(); + rpcResultBool = true; } catch (ConstructionException e) { LOG.error(e.getMessage()); @@ -108,17 +101,24 @@ public class FlowStatisticsAdapter implements OpendaylightFlowStatisticsService, return Futures.immediateFuture(Rpcs.getRpcResult(rpcResultBool, rpcResultType, null)); } + /** + * Essentially this API will return the same result as getAllFlowStatisticsFromFlowTable + */ @Override - public Future> getFlowStatistics(GetFlowStatisticsInput input) { - GetFlowStatisticsOutput rpcResultType = null; + public Future> getAllFlowsStatisticsFromAllFlowTables( + GetAllFlowsStatisticsFromAllFlowTablesInput input) { + + GetAllFlowsStatisticsFromAllFlowTablesOutput rpcResultType = null; boolean rpcResultBool = false; try { - Node node = NodeMapping.toADNode(input.getNode()); - Flow flow = ToSalConversionsUtils.toFlow(input); - FlowOnNode readFlow = readDelegate.readFlow(node, flow); - FlowStatistics flowOnNodeToFlowStatistics = toOdFlowStatistics(readFlow); - rpcResultType = new GetFlowStatisticsOutputBuilder(flowOnNodeToFlowStatistics).build(); + Node adNode = NodeMapping.toADNode(input.getNode()); + List flowsOnNode = readDelegate.readAllFlows(adNode); + List flowsStatistics = toOdFlowsStatistics(flowsOnNode); + GetAllFlowsStatisticsFromAllFlowTablesOutputBuilder builder = new GetAllFlowsStatisticsFromAllFlowTablesOutputBuilder(); + builder.setTransactionId(new TransactionId(new BigInteger("0"))); + rpcResultType = builder.setFlowAndStatisticsMapList(flowsStatistics).build(); + rpcResultBool = true; } catch (ConstructionException e) { LOG.error(e.getMessage()); @@ -128,38 +128,18 @@ public class FlowStatisticsAdapter implements OpendaylightFlowStatisticsService, } @Override - public Future> getFlowTableStatistics(GetFlowTableStatisticsInput input) { - GetFlowTableStatisticsOutput rpcResultType = null; + public Future> getFlowStatisticsFromFlowTable( + GetFlowStatisticsFromFlowTableInput input) { + GetFlowStatisticsFromFlowTableOutput rpcResultType = null; boolean rpcResultBool = false; try { Node node = NodeMapping.toADNode(input.getNode()); - List nodesTable = readDelegate.readNodeTable(node); - NodeTableStatistics nodeTable = null; - if (!nodesTable.isEmpty()) { - nodeTable = nodesTable.get(0); - rpcResultType = toOdTableStatistics(nodeTable); - rpcResultBool = true; - } - } catch (ConstructionException e) { - LOG.error(e.getMessage()); - } - - return Futures.immediateFuture(Rpcs.getRpcResult(rpcResultBool, rpcResultType, null)); - } - - @Override - public Future> getNodeConnectorStatistics( - GetNodeConnectorStatisticsInput input) { - GetNodeConnectorStatisticsOutput rpcResultType = null; - boolean rpcResultBool = false; - - NodeConnectorRef nodeConnector = input.getNodeConnector(); - try { - NodeConnectorStatistics nodeConnectorStats = readDelegate.readNodeConnector(NodeMapping - .toADNodeConnector(nodeConnector)); - org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.get.all.node.connector.statistics.output.NodeConnectorStatistics odNodeConnectorStatistics = toOdNodeConnectorStatistics(nodeConnectorStats); - rpcResultType = new GetNodeConnectorStatisticsOutputBuilder(odNodeConnectorStatistics).build(); + Flow flow = ToSalConversionsUtils.toFlow(input); + FlowOnNode readFlow = readDelegate.readFlow(node, flow); + List flowOnNodeToFlowStatistics = new ArrayList(); + flowOnNodeToFlowStatistics.add(toOdFlowStatistics(readFlow)); + rpcResultType = new GetFlowStatisticsFromFlowTableOutputBuilder().setFlowAndStatisticsMapList(flowOnNodeToFlowStatistics).build(); rpcResultBool = true; } catch (ConstructionException e) { LOG.error(e.getMessage()); @@ -169,59 +149,74 @@ public class FlowStatisticsAdapter implements OpendaylightFlowStatisticsService, } @Override - public void descriptionStatisticsUpdated(Node node, NodeDescription nodeDescription) { - - // TODO which *StatisticsUpdated interface should be used? - + public void nodeFlowStatisticsUpdated(Node node, List flowStatsList) { + List flowStatistics = toOdFlowsStatistics(flowStatsList); + FlowsStatisticsUpdateBuilder flowsStatisticsUpdateBuilder = new FlowsStatisticsUpdateBuilder(); + flowsStatisticsUpdateBuilder.setFlowAndStatisticsMapList(flowStatistics); + flowsStatisticsUpdateBuilder.setMoreReplies(false); + flowsStatisticsUpdateBuilder.setTransactionId(null); + flowsStatisticsUpdateBuilder.setId(InventoryMapping.toNodeKey(node).getId()); + notifier.publish(flowsStatisticsUpdateBuilder.build()); } @Override public void nodeConnectorStatisticsUpdated(Node node, List ncStatsList) { - for (NodeConnectorStatistics ndConStats : ncStatsList) { - org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.get.all.node.connector.statistics.output.NodeConnectorStatistics odNodeConnectorStatistics; - odNodeConnectorStatistics = toOdNodeConnectorStatistics(ndConStats); - NodeConnectorStatisticsUpdatedBuilder statisticsBuilder = new NodeConnectorStatisticsUpdatedBuilder( - odNodeConnectorStatistics); - notifier.publish(statisticsBuilder.build()); - } - } - - @Override - public void nodeFlowStatisticsUpdated(Node node, List flowStatsList) { - for (FlowOnNode flowOnNode : flowStatsList) { - FlowStatistics flowStatistics = toOdFlowStatistics(flowOnNode); - FlowStatisticsUpdatedBuilder statisticsBuilder = new FlowStatisticsUpdatedBuilder(flowStatistics); - notifier.publish(statisticsBuilder.build()); - } + NodeConnectorStatisticsUpdateBuilder nodeConnectorStatisticsUpdateBuilder = new NodeConnectorStatisticsUpdateBuilder(); + List nodeConnectorStatistics = toOdNodeConnectorStatistics(ncStatsList); + + nodeConnectorStatisticsUpdateBuilder.setNodeConnectorStatisticsAndPortNumberMap(nodeConnectorStatistics); + nodeConnectorStatisticsUpdateBuilder.setMoreReplies(false); + nodeConnectorStatisticsUpdateBuilder.setTransactionId(null); + nodeConnectorStatisticsUpdateBuilder.setId(InventoryMapping.toNodeKey(node).getId()); + notifier.publish(nodeConnectorStatisticsUpdateBuilder.build()); } @Override public void nodeTableStatisticsUpdated(Node node, List tableStatsList) { - // TODO : Not implemented by AD-SAL. + + FlowTableStatisticsUpdateBuilder flowTableStatisticsUpdateBuilder = new FlowTableStatisticsUpdateBuilder(); + + List flowTableStatistics = toOdFlowTableStatistics(tableStatsList); + flowTableStatisticsUpdateBuilder.setFlowTableAndStatisticsMap(flowTableStatistics); + flowTableStatisticsUpdateBuilder.setMoreReplies(false); + flowTableStatisticsUpdateBuilder.setTransactionId(null); + flowTableStatisticsUpdateBuilder.setId(InventoryMapping.toNodeKey(node).getId()); + notifier.publish(flowTableStatisticsUpdateBuilder.build()); +} + + @Override + public void descriptionStatisticsUpdated(Node node, NodeDescription nodeDescription) { + // TODO which *StatisticsUpdated interface should be used? + } - private List toOdFlowsStatistics(List flowsOnNode) { - List flowsStatistics = new ArrayList<>(); + private List toOdFlowsStatistics(List flowsOnNode) { + List flowsStatistics = new ArrayList<>(); for (FlowOnNode flowOnNode : flowsOnNode) { flowsStatistics.add(toOdFlowStatistics(flowOnNode)); } return flowsStatistics; } - private FlowStatistics toOdFlowStatistics(FlowOnNode flowOnNode) { - FlowStatisticsBuilder builder = new FlowStatisticsBuilder(); + private FlowAndStatisticsMapList toOdFlowStatistics(FlowOnNode flowOnNode) { + FlowAndStatisticsMapListBuilder builder = new FlowAndStatisticsMapListBuilder(); builder.setByteCount(toCounter64(flowOnNode.getByteCount())); builder.setPacketCount(toCounter64(flowOnNode.getPacketCount())); builder.setDuration(extractDuration(flowOnNode)); - + builder.setMatch(FromSalConversionsUtils.toMatch(flowOnNode.getFlow().getMatch())); + builder.setPriority((int)flowOnNode.getFlow().getPriority()); + builder.setHardTimeout((int)flowOnNode.getFlow().getHardTimeout()); + builder.setIdleTimeout((int)flowOnNode.getFlow().getIdleTimeout()); + //TODO: actions to instruction conversion + builder.setInstructions(null); return builder.build(); } - private Duration extractDuration(FlowOnNode flowOnNode) { + private org.opendaylight.yang.gen.v1.urn.opendaylight.model.statistics.types.rev130925.duration.Duration extractDuration(FlowOnNode flowOnNode) { DurationBuilder builder = new DurationBuilder(); - builder.setNanosecond(toCounter64(flowOnNode.getDurationNanoseconds())); - builder.setSecond(toCounter64(flowOnNode.getDurationSeconds())); + builder.setNanosecond(new Counter32((long)flowOnNode.getDurationNanoseconds())); + builder.setSecond(new Counter32((long)flowOnNode.getDurationSeconds())); return builder.build(); } @@ -231,38 +226,43 @@ public class FlowStatisticsAdapter implements OpendaylightFlowStatisticsService, return new Counter64(byteCountBigInt); } - private Counter64 toCounter64(int num) { - String byteCountStr = String.valueOf(num); - BigInteger byteCountBigInt = new BigInteger(byteCountStr); - return new Counter64(byteCountBigInt); - } - - private List toOdNodesConnectorStatistics( - List nodesConnectorStatistics) { - List odNodesConnectorStatistics = new ArrayList<>(); - for (NodeConnectorStatistics nodeConnectorStatistics : nodesConnectorStatistics) { - odNodesConnectorStatistics.add(toOdNodeConnectorStatistics(nodeConnectorStatistics)); + private List toOdFlowTableStatistics(List tableStatsList) { + + List flowTableStatsMap = new ArrayList(); + for (NodeTableStatistics nodeTableStatistics : tableStatsList) { + FlowTableAndStatisticsMapBuilder flowTableAndStatisticsMapBuilder = new FlowTableAndStatisticsMapBuilder(); + flowTableAndStatisticsMapBuilder.setActiveFlows(new Counter32((long) nodeTableStatistics.getActiveCount())); + flowTableAndStatisticsMapBuilder.setPacketsLookedUp(toCounter64(nodeTableStatistics.getLookupCount())); + flowTableAndStatisticsMapBuilder.setPacketsMatched(toCounter64(nodeTableStatistics.getMatchedCount())); + flowTableAndStatisticsMapBuilder.setActiveFlows(new Counter32((long) nodeTableStatistics.getActiveCount())); + flowTableAndStatisticsMapBuilder.setTableId(new TableId((short)nodeTableStatistics.getNodeTable().getID())); + flowTableStatsMap.add(flowTableAndStatisticsMapBuilder.build()); } - return odNodesConnectorStatistics; + + return flowTableStatsMap; } - private org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.get.all.node.connector.statistics.output.NodeConnectorStatistics toOdNodeConnectorStatistics( - NodeConnectorStatistics ndConStats) { - NodeConnectorStatisticsBuilder builder = new NodeConnectorStatisticsBuilder(); - - builder.setBytes(extractBytes(ndConStats)); - builder.setCollisionCount(toBI(ndConStats.getCollisionCount())); - builder.setDuration(null); - builder.setPackets(extractPackets(ndConStats)); - builder.setReceiveCrcError(toBI(ndConStats.getReceiveCRCErrorCount())); - builder.setReceiveDrops(toBI(ndConStats.getReceiveDropCount())); - builder.setReceiveErrors(toBI(ndConStats.getReceiveErrorCount())); - builder.setReceiveFrameError(toBI(ndConStats.getReceiveFrameErrorCount())); - builder.setReceiveOverRunError(toBI(ndConStats.getReceiveOverRunErrorCount())); - builder.setTransmitDrops(toBI(ndConStats.getTransmitDropCount())); - builder.setTransmitErrors(toBI(ndConStats.getTransmitErrorCount())); - - return builder.build(); + private List toOdNodeConnectorStatistics( + List ncStatsList) { + List nodeConnectorStatisticsList = new ArrayList(); + for(NodeConnectorStatistics ofNodeConnectorStatistics : ncStatsList){ + NodeConnectorStatisticsAndPortNumberMapBuilder nodeConnectorStatisticsAndPortNumberMapBuilder = new NodeConnectorStatisticsAndPortNumberMapBuilder(); + + nodeConnectorStatisticsAndPortNumberMapBuilder.setBytes(extractBytes(ofNodeConnectorStatistics)); + nodeConnectorStatisticsAndPortNumberMapBuilder.setCollisionCount(toBI(ofNodeConnectorStatistics.getCollisionCount())); + nodeConnectorStatisticsAndPortNumberMapBuilder.setDuration(null); + nodeConnectorStatisticsAndPortNumberMapBuilder.setPackets(extractPackets(ofNodeConnectorStatistics)); + nodeConnectorStatisticsAndPortNumberMapBuilder.setReceiveCrcError(toBI(ofNodeConnectorStatistics.getReceiveCRCErrorCount())); + nodeConnectorStatisticsAndPortNumberMapBuilder.setReceiveDrops(toBI(ofNodeConnectorStatistics.getReceiveDropCount())); + nodeConnectorStatisticsAndPortNumberMapBuilder.setReceiveErrors(toBI(ofNodeConnectorStatistics.getReceiveErrorCount())); + nodeConnectorStatisticsAndPortNumberMapBuilder.setReceiveFrameError(toBI(ofNodeConnectorStatistics.getReceiveFrameErrorCount())); + nodeConnectorStatisticsAndPortNumberMapBuilder.setReceiveOverRunError(toBI(ofNodeConnectorStatistics.getReceiveOverRunErrorCount())); + nodeConnectorStatisticsAndPortNumberMapBuilder.setTransmitDrops(toBI(ofNodeConnectorStatistics.getTransmitDropCount())); + nodeConnectorStatisticsAndPortNumberMapBuilder.setTransmitErrors(toBI(ofNodeConnectorStatistics.getTransmitErrorCount())); + nodeConnectorStatisticsList.add(nodeConnectorStatisticsAndPortNumberMapBuilder.build()); + } + + return nodeConnectorStatisticsList; } private BigInteger toBI(long num) { @@ -292,49 +292,4 @@ public class FlowStatisticsAdapter implements OpendaylightFlowStatisticsService, return builder.build(); } - private GetFlowTableStatisticsOutput toOdTableStatistics(NodeTableStatistics nodeTable) { - GetFlowTableStatisticsOutputBuilder builder = new GetFlowTableStatisticsOutputBuilder(); - - builder.setActive(toCounter64(nodeTable.getActiveCount())); - builder.setLookup(toCounter64(nodeTable.getLookupCount())); - builder.setMatched(toCounter64(nodeTable.getMatchedCount())); - - return builder.build(); - } - - @Override - public Future> getAggregateFlowStatisticsFromFlowTableForAllFlows( - GetAggregateFlowStatisticsFromFlowTableForAllFlowsInput input) { - // TODO Auto-generated method stub - return null; - } - - @Override - public Future> getAggregateFlowStatisticsFromFlowTableForGivenMatch( - GetAggregateFlowStatisticsFromFlowTableForGivenMatchInput input) { - // TODO Auto-generated method stub - return null; - } - - @Override - public Future> getAllFlowStatisticsFromFlowTable( - GetAllFlowStatisticsFromFlowTableInput input) { - // TODO Auto-generated method stub - return null; - } - - @Override - public Future> getAllFlowsStatisticsFromAllFlowTables( - GetAllFlowsStatisticsFromAllFlowTablesInput input) { - // TODO Auto-generated method stub - return null; - } - - @Override - public Future> getFlowStatisticsFromFlowTable( - GetFlowStatisticsFromFlowTableInput input) { - // TODO Auto-generated method stub - return null; - } - } diff --git a/opendaylight/md-sal/forwardingrules-manager/src/main/java/org/opendaylight/controller/frm/flow/FlowTransaction.xtend b/opendaylight/md-sal/forwardingrules-manager/src/main/java/org/opendaylight/controller/frm/flow/FlowTransaction.xtend index 5203d3c1a8..6fcadea8bf 100644 --- a/opendaylight/md-sal/forwardingrules-manager/src/main/java/org/opendaylight/controller/frm/flow/FlowTransaction.xtend +++ b/opendaylight/md-sal/forwardingrules-manager/src/main/java/org/opendaylight/controller/frm/flow/FlowTransaction.xtend @@ -15,6 +15,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.N import org.opendaylight.yangtools.yang.binding.DataObject import org.opendaylight.yangtools.yang.binding.InstanceIdentifier import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SalFlowService +import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.FlowRef class FlowTransaction extends AbstractTransaction { @@ -32,6 +33,7 @@ class FlowTransaction extends AbstractTransaction { val tableInstanceId = instanceId.firstIdentifierOf(Table); val nodeInstanceId = instanceId.firstIdentifierOf(Node); val builder = new RemoveFlowInputBuilder(flow); + builder.setFlowRef(new FlowRef(instanceId)); builder.setNode(new NodeRef(nodeInstanceId)); builder.setFlowTable(new FlowTableRef(tableInstanceId)); _salFlowService.removeFlow(builder.build()); @@ -45,6 +47,7 @@ class FlowTransaction extends AbstractTransaction { val nodeInstanceId = instanceId.firstIdentifierOf(Node); val builder = new UpdateFlowInputBuilder(); builder.setNode(new NodeRef(nodeInstanceId)); + builder.setFlowRef(new FlowRef(instanceId)); val ufb = new UpdatedFlowBuilder(updatedFlow); builder.setUpdatedFlow((ufb.build())); val ofb = new OriginalFlowBuilder(originalFlow); @@ -61,6 +64,7 @@ class FlowTransaction extends AbstractTransaction { val nodeInstanceId = instanceId.firstIdentifierOf(Node); val builder = new AddFlowInputBuilder(flow); builder.setNode(new NodeRef(nodeInstanceId)); + builder.setFlowRef(new FlowRef(instanceId)); builder.setFlowTable(new FlowTableRef(tableInstanceId)); _salFlowService.addFlow(builder.build()); } diff --git a/opendaylight/md-sal/forwardingrules-manager/src/main/java/org/opendaylight/controller/frm/group/GroupTransaction.xtend b/opendaylight/md-sal/forwardingrules-manager/src/main/java/org/opendaylight/controller/frm/group/GroupTransaction.xtend index 54382ea056..d68ffa09fa 100644 --- a/opendaylight/md-sal/forwardingrules-manager/src/main/java/org/opendaylight/controller/frm/group/GroupTransaction.xtend +++ b/opendaylight/md-sal/forwardingrules-manager/src/main/java/org/opendaylight/controller/frm/group/GroupTransaction.xtend @@ -2,26 +2,18 @@ package org.opendaylight.controller.frm.group import org.opendaylight.controller.frm.AbstractTransaction import org.opendaylight.controller.md.sal.common.api.data.DataModification -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.AddFlowInputBuilder -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.FlowTableRef -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.RemoveFlowInputBuilder -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.UpdateFlowInputBuilder -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.flow.update.OriginalFlowBuilder -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.flow.update.UpdatedFlowBuilder -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.Flow +import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.AddGroupInputBuilder +import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.RemoveGroupInputBuilder +import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.SalGroupService +import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.UpdateGroupInputBuilder +import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.group.update.OriginalGroupBuilder +import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.group.update.UpdatedGroupBuilder +import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupRef +import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node import org.opendaylight.yangtools.yang.binding.DataObject import org.opendaylight.yangtools.yang.binding.InstanceIdentifier -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SalFlowService -import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.SalGroupService -import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group -import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.RemoveGroupInputBuilder -import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.UpdateGroupInputBuilder -import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.group.update.UpdatedGroupBuilder -import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.group.update.OriginalGroupBuilder -import org.opendaylight.yang.gen.v1.urn.opendaylight.group.service.rev130918.AddGroupInputBuilder class GroupTransaction extends AbstractTransaction { @@ -39,6 +31,7 @@ class GroupTransaction extends AbstractTransaction { val nodeInstanceId = instanceId.firstIdentifierOf(Node); val builder = new RemoveGroupInputBuilder(group); builder.setNode(new NodeRef(nodeInstanceId)); + builder.setGroupRef(new GroupRef(instanceId)); _groupService.removeGroup(builder.build()); } } @@ -50,6 +43,7 @@ class GroupTransaction extends AbstractTransaction { val nodeInstanceId = instanceId.firstIdentifierOf(Node); val builder = new UpdateGroupInputBuilder(); builder.setNode(new NodeRef(nodeInstanceId)); + builder.setGroupRef(new GroupRef(instanceId)); val ufb = new UpdatedGroupBuilder(updatedGroup); builder.setUpdatedGroup((ufb.build())); val ofb = new OriginalGroupBuilder(originalGroup); @@ -65,6 +59,7 @@ class GroupTransaction extends AbstractTransaction { val nodeInstanceId = instanceId.firstIdentifierOf(Node); val builder = new AddGroupInputBuilder(group); builder.setNode(new NodeRef(nodeInstanceId)); + builder.setGroupRef(new GroupRef(instanceId)); _groupService.addGroup(builder.build()); } } diff --git a/opendaylight/md-sal/forwardingrules-manager/src/main/java/org/opendaylight/controller/frm/meter/MeterTransaction.xtend b/opendaylight/md-sal/forwardingrules-manager/src/main/java/org/opendaylight/controller/frm/meter/MeterTransaction.xtend index 3ed1f40735..d64f2518a8 100644 --- a/opendaylight/md-sal/forwardingrules-manager/src/main/java/org/opendaylight/controller/frm/meter/MeterTransaction.xtend +++ b/opendaylight/md-sal/forwardingrules-manager/src/main/java/org/opendaylight/controller/frm/meter/MeterTransaction.xtend @@ -13,6 +13,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.service.rev130918.met import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.Meter import org.opendaylight.yangtools.yang.binding.DataObject import org.opendaylight.yangtools.yang.binding.InstanceIdentifier +import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.MeterRef class MeterTransaction extends AbstractTransaction { @@ -30,6 +31,7 @@ class MeterTransaction extends AbstractTransaction { val nodeInstanceId = instanceId.firstIdentifierOf(Node); val builder = new RemoveMeterInputBuilder(meter); builder.setNode(new NodeRef(nodeInstanceId)); + builder.setMeterRef(new MeterRef(instanceId)); _salMeterService.removeMeter(builder.build()); } } @@ -41,6 +43,7 @@ class MeterTransaction extends AbstractTransaction { val nodeInstanceId = instanceId.firstIdentifierOf(Node); val builder = new UpdateMeterInputBuilder(); builder.setNode(new NodeRef(nodeInstanceId)); + builder.setMeterRef(new MeterRef(instanceId)); val ufb = new UpdatedMeterBuilder(updatedMeter); builder.setUpdatedMeter((ufb.build())); val ofb = new OriginalMeterBuilder(originalMeter); @@ -56,6 +59,7 @@ class MeterTransaction extends AbstractTransaction { val nodeInstanceId = instanceId.firstIdentifierOf(Node); val builder = new AddMeterInputBuilder(meter); builder.setNode(new NodeRef(nodeInstanceId)); + builder.setMeterRef(new MeterRef(instanceId)); _salMeterService.addMeter(builder.build()); } } diff --git a/opendaylight/md-sal/model/model-flow-base/src/main/yang/group-types.yang b/opendaylight/md-sal/model/model-flow-base/src/main/yang/group-types.yang index 8c874e2fe8..4442fbb335 100644 --- a/opendaylight/md-sal/model/model-flow-base/src/main/yang/group-types.yang +++ b/opendaylight/md-sal/model/model-flow-base/src/main/yang/group-types.yang @@ -84,6 +84,10 @@ module opendaylight-group-types { description "Check chaining for loops and delete"; } + typedef group-ref { + type instance-identifier; + } + grouping group { leaf group-type { @@ -102,10 +106,6 @@ module opendaylight-group-types { type string; } - leaf install { - type boolean; - } - leaf barrier { type boolean; } diff --git a/opendaylight/md-sal/model/model-flow-base/src/main/yang/meter-types.yang b/opendaylight/md-sal/model/model-flow-base/src/main/yang/meter-types.yang index b380af2212..d84b2f0851 100644 --- a/opendaylight/md-sal/model/model-flow-base/src/main/yang/meter-types.yang +++ b/opendaylight/md-sal/model/model-flow-base/src/main/yang/meter-types.yang @@ -112,6 +112,10 @@ module opendaylight-meter-types { } } + typedef meter-ref { + type instance-identifier; + } + grouping meter { leaf flags { @@ -120,11 +124,12 @@ module opendaylight-meter-types { leaf meter-id { type meter-id; - } + } - leaf install { + leaf barrier { type boolean; } + leaf meter-name { type string; } diff --git a/opendaylight/md-sal/model/model-flow-base/src/main/yang/opendaylight-flow-types.yang b/opendaylight/md-sal/model/model-flow-base/src/main/yang/opendaylight-flow-types.yang index 2bcd405223..a0beb2a84c 100644 --- a/opendaylight/md-sal/model/model-flow-base/src/main/yang/opendaylight-flow-types.yang +++ b/opendaylight/md-sal/model/model-flow-base/src/main/yang/opendaylight-flow-types.yang @@ -12,6 +12,10 @@ module opendaylight-flow-types { description "Initial revision of flow service"; } + typedef flow-ref { + type instance-identifier; + } + typedef output-port-values { type enumeration { enum MAX { diff --git a/opendaylight/md-sal/model/model-flow-service/src/main/yang/flow-service.yang b/opendaylight/md-sal/model/model-flow-service/src/main/yang/flow-service.yang index 07678f57e1..d6a31c30de 100644 --- a/opendaylight/md-sal/model/model-flow-service/src/main/yang/flow-service.yang +++ b/opendaylight/md-sal/model/model-flow-service/src/main/yang/flow-service.yang @@ -51,6 +51,9 @@ module sal-flow { rpc add-flow { input { + leaf flow-ref { + type types:flow-ref; + } uses node-flow; uses tr:transaction-aware; } @@ -61,6 +64,9 @@ module sal-flow { rpc remove-flow { input { + leaf flow-ref { + type types:flow-ref; + } uses node-flow; uses tr:transaction-aware; } @@ -71,6 +77,9 @@ module sal-flow { rpc update-flow { input { + leaf flow-ref { + type types:flow-ref; + } uses flow-update; uses tr:transaction-aware; } @@ -80,15 +89,28 @@ module sal-flow { } notification flow-added { + leaf flow-ref { + type types:flow-ref; + } uses node-flow; + uses tr:transaction-aware; } notification flow-updated { + leaf flow-ref { + type types:flow-ref; + } uses node-flow; + uses tr:transaction-aware; + } notification flow-removed { + leaf flow-ref { + type types:flow-ref; + } uses node-flow; + uses tr:transaction-aware; } notification switch-flow-removed { diff --git a/opendaylight/md-sal/model/model-flow-service/src/main/yang/group-service.yang b/opendaylight/md-sal/model/model-flow-service/src/main/yang/group-service.yang index 9106bca8a4..6cc1537ebc 100644 --- a/opendaylight/md-sal/model/model-flow-service/src/main/yang/group-service.yang +++ b/opendaylight/md-sal/model/model-flow-service/src/main/yang/group-service.yang @@ -31,6 +31,9 @@ module sal-group { rpc add-group { input { + leaf group-ref { + type group-type:group-ref; + } uses node-group; uses tr:transaction-aware; } @@ -41,6 +44,9 @@ module sal-group { rpc remove-group { input { + leaf group-ref { + type group-type:group-ref; + } uses node-group; uses tr:transaction-aware; } @@ -51,6 +57,9 @@ module sal-group { rpc update-group { input { + leaf group-ref { + type group-type:group-ref; + } uses group-update; uses tr:transaction-aware; } @@ -60,14 +69,26 @@ module sal-group { } notification group-added { + leaf group-ref { + type group-type:group-ref; + } uses node-group; + uses tr:transaction-aware; } notification group-updated { + leaf group-ref { + type group-type:group-ref; + } uses node-group; + uses tr:transaction-aware; } notification group-removed { + leaf group-ref { + type group-type:group-ref; + } uses node-group; + uses tr:transaction-aware; } } \ No newline at end of file diff --git a/opendaylight/md-sal/model/model-flow-service/src/main/yang/meter-service.yang b/opendaylight/md-sal/model/model-flow-service/src/main/yang/meter-service.yang index c187181e5e..6205fed529 100644 --- a/opendaylight/md-sal/model/model-flow-service/src/main/yang/meter-service.yang +++ b/opendaylight/md-sal/model/model-flow-service/src/main/yang/meter-service.yang @@ -31,6 +31,9 @@ module sal-meter { rpc add-meter { input { + leaf meter-ref { + type meter-type:meter-ref; + } uses node-meter; uses tr:transaction-aware; } @@ -41,6 +44,10 @@ module sal-meter { rpc remove-meter { input { + leaf meter-ref { + type meter-type:meter-ref; + } + uses node-meter; uses tr:transaction-aware; } @@ -51,6 +58,10 @@ module sal-meter { rpc update-meter { input { + leaf meter-ref { + type meter-type:meter-ref; + } + uses meter-update; uses tr:transaction-aware; } @@ -60,14 +71,26 @@ module sal-meter { } notification meter-added { + leaf meter-ref { + type meter-type:meter-ref; + } uses node-meter; + uses tr:transaction-aware; } notification meter-updated { + leaf meter-ref { + type meter-type:meter-ref; + } uses node-meter; + uses tr:transaction-aware; } notification meter-removed { + leaf meter-ref { + type meter-type:meter-ref; + } uses node-meter; + uses tr:transaction-aware; } } \ No newline at end of file diff --git a/opendaylight/md-sal/model/model-flow-service/src/main/yang/port-service.yang b/opendaylight/md-sal/model/model-flow-service/src/main/yang/port-service.yang index d49675ad39..6795e6fd67 100644 --- a/opendaylight/md-sal/model/model-flow-service/src/main/yang/port-service.yang +++ b/opendaylight/md-sal/model/model-flow-service/src/main/yang/port-service.yang @@ -43,9 +43,14 @@ module sal-port { output { uses port-type:flow-capable-port; } - } + } + + notification port-updated { + uses port-update; + uses tr:transaction-aware; + } notification port-removed { - uses node-port; + uses node-port; } } \ No newline at end of file diff --git a/opendaylight/md-sal/model/model-flow-statistics/src/main/yang/flow-statistics.yang b/opendaylight/md-sal/model/model-flow-statistics/src/main/yang/flow-statistics.yang index 3bd37bcf33..7bbcca3a12 100644 --- a/opendaylight/md-sal/model/model-flow-statistics/src/main/yang/flow-statistics.yang +++ b/opendaylight/md-sal/model/model-flow-statistics/src/main/yang/flow-statistics.yang @@ -115,7 +115,7 @@ module opendaylight-flow-statistics { } } - // RPC calls to fetch flow statistics + // RPC calls to fetch aggregate flow statistics rpc get-aggregate-flow-statistics-from-flow-table-for-all-flows { description "Fetch aggregate statistics for all the flows present in the specific flow table of the switch"; input { @@ -150,76 +150,4 @@ module opendaylight-flow-statistics { uses stat-types:aggregate-flow-statistics; uses tr:transaction-aware; } - - //Keeping flow statistics RPC call for backward compatibility for sal-compatibility layer --START - rpc get-flow-statistics { - input { - uses inv:node-context-ref; - uses flow-types:flow; - } - output { - uses flow-types:flow-statistics; - } - } - - rpc get-all-flow-statistics { - input { - uses inv:node-context-ref; - } - output { - list flow-statistics { - uses flow-types:flow-statistics; - } - } - } - - notification flow-statistics-updated { - uses flow-types:flow-statistics; - } - - //Keeping flow statistics RPC call for backward compatibility for sal-compatibility layer --END - - //RPC call to fetch node connector statistics - rpc get-node-connector-statistics { - input { - uses inv:node-context-ref; - leaf node-connector { - type inv:node-connector-ref; - } - } - output { - uses stat-types:node-connector-statistics; - } - } - - rpc get-all-node-connector-statistics { - input { - uses inv:node-context-ref; - } - output { - list node-connector-statistics { - uses stat-types:node-connector-statistics; - } - } - } - - rpc get-flow-table-statistics { - input { - uses inv:node-context-ref; - } - output { - uses flow-types:flow-table-statistics; - } - } - - notification flow-table-statistics-updated { - leaf flow-table { - type flow:flow-table-ref; - } - uses flow-types:flow-table-statistics; - } - - notification node-connector-statistics-updated { - uses stat-types:node-connector-statistics; - } } diff --git a/opendaylight/md-sal/model/model-flow-statistics/src/main/yang/port-statistics.yang b/opendaylight/md-sal/model/model-flow-statistics/src/main/yang/port-statistics.yang index 0cb6a60cfe..787a4e6aa0 100644 --- a/opendaylight/md-sal/model/model-flow-statistics/src/main/yang/port-statistics.yang +++ b/opendaylight/md-sal/model/model-flow-statistics/src/main/yang/port-statistics.yang @@ -30,19 +30,19 @@ module opendaylight-port-statistics { } // RPC calls - rpc get-all-ports-statistics { - description "Get statistics for all the ports from the node"; + rpc get-all-node-connectors-statistics { + description "Get statistics for all node connectors from the node"; input { uses inv:node-context-ref; } output { - uses stat-types:node-connector-statistics; + uses node-connector-statistics-and-port-number-map; uses tr:transaction-aware; } } - rpc get-port-statistics { - description "Get statistics for given port from the node"; + rpc get-node-connector-statistics { + description "Get statistics for given node connector from the node"; input { uses inv:node-context-ref; leaf node-connector-id { @@ -55,9 +55,9 @@ module opendaylight-port-statistics { } } - //Notification for port statistics update + //Notification for node connector statistics update grouping node-connector-statistics-and-port-number-map { - description "List of flow and statistics map"; + description "List of map - node connectors and their statistics"; list node-connector-statistics-and-port-number-map { key "node-connector-id"; leaf node-connector-id { @@ -67,7 +67,7 @@ module opendaylight-port-statistics { } } - notification port-statistics-update { + notification node-connector-statistics-update { leaf moreReplies { type boolean; } diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/binding/impl/BindingBrokerImplModule.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/binding/impl/BindingBrokerImplModule.java index 48c33ad0fc..c46b0dd6b4 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/binding/impl/BindingBrokerImplModule.java +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/config/yang/md/sal/binding/impl/BindingBrokerImplModule.java @@ -36,7 +36,7 @@ public final class BindingBrokerImplModule extends org.opendaylight.controller.c @Override public java.lang.AutoCloseable createInstance() { - BindingAwareBrokerImpl broker = new BindingAwareBrokerImpl(getBundleContext()); + BindingAwareBrokerImpl broker = new BindingAwareBrokerImpl(getIdentifier().getInstanceName(),getBundleContext()); broker.setDataBroker(getDataBrokerDependency()); broker.setNotifyBroker(getNotificationServiceDependency()); broker.start(); diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/RuntimeCodeGenerator.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/RuntimeCodeGenerator.java index 6672d953a2..7789a06fe8 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/RuntimeCodeGenerator.java +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/RuntimeCodeGenerator.java @@ -86,7 +86,7 @@ public interface RuntimeCodeGenerator { * @return Instance of RpcService of provided serviceType which implements * also {@link RpcRouter} and {@link DelegateProxy} */ - RpcRouter getRouterFor(Class serviceType) throws IllegalArgumentException; + RpcRouter getRouterFor(Class serviceType,String name) throws IllegalArgumentException; NotificationInvokerFactory getInvokerFactory(); } diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/RpcRouterCodegenInstance.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/RpcRouterCodegenInstance.java index 780d0bd4c7..8b2db8b13c 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/RpcRouterCodegenInstance.java +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/RpcRouterCodegenInstance.java @@ -45,16 +45,23 @@ public class RpcRouterCodegenInstance implements // private final Map, RpcRoutingTableImpl> routingTables; - public RpcRouterCodegenInstance(Class type, T routerImpl, Set> contexts, + private final String name; + + @SuppressWarnings("unchecked") + public RpcRouterCodegenInstance(String name,Class type, T routerImpl, Set> contexts, Set> inputs) { + this.name = name; this.listeners = ListenerRegistry.create(); this.serviceType = type; this.invocationProxy = routerImpl; this.contexts = ImmutableSet.copyOf(contexts); Map, RpcRoutingTableImpl> mutableRoutingTables = new HashMap<>(); for (Class ctx : contexts) { - RpcRoutingTableImpl table = new RpcRoutingTableImpl<>(ctx); + RpcRoutingTableImpl table = new RpcRoutingTableImpl<>(name,ctx,type); + + @SuppressWarnings("rawtypes") Map invokerView = table.getRoutes(); + setRoutingTable((RpcService) invocationProxy, ctx, invokerView); mutableRoutingTables.put(ctx, table); table.registerRouteChangeListener(this); diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/RpcRoutingTableImpl.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/RpcRoutingTableImpl.java index f9592351f6..808358fb35 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/RpcRoutingTableImpl.java +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/RpcRoutingTableImpl.java @@ -15,8 +15,11 @@ import org.opendaylight.controller.md.sal.common.api.routing.RouteChangePublishe import org.opendaylight.controller.md.sal.common.api.routing.RouteChangeListener; import org.opendaylight.controller.md.sal.common.impl.routing.RoutingUtils; import org.opendaylight.yangtools.concepts.AbstractObjectRegistration; +import org.opendaylight.yangtools.concepts.Identifiable; import org.opendaylight.yangtools.concepts.ListenerRegistration; import org.opendaylight.yangtools.concepts.Mutable; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; class RpcRoutingTableImpl // implements // @@ -24,16 +27,22 @@ implements // RpcRoutingTable, // RouteChangePublisher, InstanceIdentifier> { - private final Class identifier; + private static final Logger LOGGER = LoggerFactory.getLogger(RpcRoutingTableImpl.class); + private final String routerName; + private final Class serviceType; + + private final Class contextType; private final ConcurrentMap, S> routes; private final Map, S> unmodifiableRoutes; private RouteChangeListener, InstanceIdentifier> listener; private S defaultRoute; - - public RpcRoutingTableImpl(Class identifier) { + + public RpcRoutingTableImpl(String routerName,Class contextType, Class serviceType) { super(); - this.identifier = identifier; + this.routerName = routerName; + this.serviceType = serviceType; + this.contextType = contextType; this.routes = new ConcurrentHashMap<>(); this.unmodifiableRoutes = Collections.unmodifiableMap(routes); } @@ -56,17 +65,19 @@ implements // @Override public Class getIdentifier() { - return identifier; + return contextType; } @Override @SuppressWarnings("unchecked") public void updateRoute(InstanceIdentifier path, S service) { S previous = this.routes.put(path, service); + + LOGGER.debug("Route {} updated to {} in routing table {}",path,service,this); @SuppressWarnings("rawtypes") RouteChangeListener listenerCapture = listener; if (previous == null && listenerCapture != null) { - listenerCapture.onRouteChange(RoutingUtils.announcementChange(identifier, path)); + listenerCapture.onRouteChange(RoutingUtils.announcementChange(contextType, path)); } } @@ -75,10 +86,11 @@ implements // @SuppressWarnings("unchecked") public void removeRoute(InstanceIdentifier path) { S previous = this.routes.remove(path); + LOGGER.debug("Route {} to {} removed in routing table {}",path,previous,this); @SuppressWarnings("rawtypes") RouteChangeListener listenerCapture = listener; if (previous != null && listenerCapture != null) { - listenerCapture.onRouteChange(RoutingUtils.removalChange(identifier, path)); + listenerCapture.onRouteChange(RoutingUtils.removalChange(contextType, path)); } } @@ -86,7 +98,8 @@ implements // @SuppressWarnings("rawtypes") RouteChangeListener listenerCapture = listener; if (routes.remove(path, service) && listenerCapture != null) { - listenerCapture.onRouteChange(RoutingUtils.removalChange(identifier, path)); + LOGGER.debug("Route {} to {} removed in routing table {}",path,service,this); + listenerCapture.onRouteChange(RoutingUtils.removalChange(contextType, path)); } } @@ -107,6 +120,16 @@ implements // protected void removeAllReferences(S service) { } + + + + @Override + public String toString() { + return "RpcRoutingTableImpl [router=" + routerName + ", service=" + serviceType.getSimpleName() + ", context=" + + contextType.getSimpleName() + "]"; + } + + private class SingletonListenerRegistration, InstanceIdentifier>> extends AbstractObjectRegistration diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/RuntimeCodeGenerator.xtend b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/RuntimeCodeGenerator.xtend index 8b41552857..d9e0983cfa 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/RuntimeCodeGenerator.xtend +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/RuntimeCodeGenerator.xtend @@ -91,7 +91,7 @@ class RuntimeCodeGenerator implements org.opendaylight.controller.sal.binding.co return instance; } - override getRouterFor(Class iface) { + override getRouterFor(Class iface,String routerInstanceName) { val metadata = withClassLoader(iface.classLoader) [| val supertype = iface.asCtClass return supertype.rpcMetadata; @@ -148,7 +148,7 @@ class RuntimeCodeGenerator implements org.opendaylight.controller.sal.binding.co return targetCls.toClass(iface.classLoader,iface.protectionDomain).newInstance as T ]; - return new RpcRouterCodegenInstance(iface, instance, metadata.contexts,metadata.supportedInputs); + return new RpcRouterCodegenInstance(routerInstanceName,iface, instance, metadata.contexts,metadata.supportedInputs); } private def RpcServiceMetadata getRpcMetadata(CtClass iface) { diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/XtendHelper.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/XtendHelper.java index 588bc789cf..ca1b6344e6 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/XtendHelper.java +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/codegen/impl/XtendHelper.java @@ -9,11 +9,6 @@ import org.opendaylight.yangtools.yang.model.api.type.UnionTypeDefinition; public class XtendHelper { - public static RpcRoutingTableImpl createRoutingTable( - Class cls) { - return new RpcRoutingTableImpl<>(cls); - } - @SuppressWarnings({"rawtypes","unchecked"}) public static Iterable getTypes(UnionTypeDefinition definition) { return (Iterable) (List) definition.getTypes(); diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/dom/serializer/impl/TransformerGenerator.xtend b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/dom/serializer/impl/TransformerGenerator.xtend index e5bd3e7b9a..5bc2d70c6a 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/dom/serializer/impl/TransformerGenerator.xtend +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/dom/serializer/impl/TransformerGenerator.xtend @@ -145,9 +145,13 @@ class TransformerGenerator { if (typeSpecBuilder == null) { typeSpecBuilder = pathToType.get(node.path); } + var schemaNode = typeToSchemaNode.get(ref); + if(schemaNode === null) { + schemaNode = node; + } checkState(typeSpecBuilder !== null, "Could not find TypeDefinition for %s, $s", inputType.name, node); val typeSpec = typeSpecBuilder.toInstance(); - val newret = generateTransformerFor(inputType, typeSpec, node); + val newret = generateTransformerFor(inputType, typeSpec, schemaNode); listener.onClassProcessed(inputType); return newret as Class, Object>>; ] @@ -524,7 +528,7 @@ class TransformerGenerator { return null; } java.util.Map _compositeNode = (java.util.Map) $2; - ////System.out.println(_localQName + " " + _compositeNode); + System.out.println(_localQName + " " + _compositeNode); «type.builderName» _builder = new «type.builderName»(); boolean _is_empty = true; «FOR child : node.childNodes» @@ -672,6 +676,7 @@ class TransformerGenerator { return null; } java.util.Map _compositeNode = (java.util.Map) $2; + System.out.println(_localQName + " " + _compositeNode); «type.builderName» _builder = new «type.builderName»(); «deserializeKey(type, node)» «deserializeDataNodeContainerBody(type, node)» @@ -687,6 +692,7 @@ class TransformerGenerator { return null; } java.util.Map _compositeNode = (java.util.Map) $2; + System.out.println(_localQName + " " + _compositeNode); «type.builderName» _builder = new «type.builderName»(); «deserializeDataNodeContainerBody(type, node)» «deserializeAugmentations» @@ -702,7 +708,7 @@ class TransformerGenerator { return null; } java.util.Map _compositeNode = (java.util.Map) $2; - ////System.out.println(_localQName + " " + _compositeNode); + System.out.println(_localQName + " " + _compositeNode); «type.builderName» _builder = new «type.builderName»(); «deserializeDataNodeContainerBody(type, node)» «deserializeAugmentations» diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/BindingAwareBrokerImpl.xtend b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/BindingAwareBrokerImpl.xtend index 8d3545fbbb..b4bf3f5a83 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/BindingAwareBrokerImpl.xtend +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/BindingAwareBrokerImpl.xtend @@ -9,47 +9,16 @@ package org.opendaylight.controller.sal.binding.impl import org.opendaylight.controller.sal.binding.api.BindingAwareConsumer import org.opendaylight.controller.sal.binding.api.BindingAwareProvider -import org.opendaylight.yangtools.yang.binding.RpcService -import javassist.ClassPool import org.osgi.framework.BundleContext -import java.util.Map -import javassist.LoaderClassPath import org.opendaylight.controller.sal.binding.api.BindingAwareBroker -import java.util.Hashtable -import static extension org.opendaylight.controller.sal.binding.codegen.RuntimeCodeHelper.* - import org.opendaylight.controller.sal.binding.api.NotificationProviderService -import org.osgi.framework.ServiceRegistration -import static org.opendaylight.controller.sal.binding.impl.osgi.Constants.* -import static extension org.opendaylight.controller.sal.binding.impl.osgi.PropertiesUtils.* -import org.opendaylight.controller.sal.binding.api.NotificationService import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.ProviderContext - -import org.slf4j.LoggerFactory -import org.opendaylight.controller.sal.binding.codegen.impl.RuntimeCodeGenerator import org.opendaylight.yangtools.yang.binding.InstanceIdentifier -import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RoutedRpcRegistration -import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RpcRegistration -import org.opendaylight.controller.sal.binding.api.data.DataProviderService -import org.opendaylight.controller.sal.binding.api.data.DataBrokerService -import org.opendaylight.controller.sal.binding.spi.RpcRouter -import java.util.concurrent.ConcurrentHashMap -import static com.google.common.base.Preconditions.* -import org.opendaylight.yangtools.concepts.AbstractObjectRegistration -import org.opendaylight.yangtools.yang.binding.BaseIdentity -import com.google.common.collect.Multimap -import com.google.common.collect.HashMultimap -import static org.opendaylight.controller.sal.binding.impl.util.ClassLoaderUtils.* -import java.util.concurrent.Executors -import java.util.Collections import org.opendaylight.yangtools.yang.binding.DataObject -import java.util.concurrent.locks.ReentrantLock -import java.util.concurrent.Callable -import java.util.WeakHashMap -import javax.annotation.concurrent.GuardedBy -import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry -import org.opendaylight.yangtools.concepts.ListenerRegistration -import org.opendaylight.yangtools.concepts.util.ListenerRegistry +import org.opendaylight.controller.md.sal.common.api.routing.RouteChangeListener +import org.opendaylight.controller.sal.binding.spi.RpcContextIdentifier +import org.opendaylight.controller.sal.binding.api.data.DataProviderService +import org.slf4j.LoggerFactory class BindingAwareBrokerImpl extends RpcProviderRegistryImpl implements BindingAwareBroker, AutoCloseable { private static val log = LoggerFactory.getLogger(BindingAwareBrokerImpl) @@ -65,7 +34,8 @@ class BindingAwareBrokerImpl extends RpcProviderRegistryImpl implements BindingA @Property var BundleContext brokerBundleContext - public new(BundleContext bundleContext) { + public new(String name,BundleContext bundleContext) { + super(name); _brokerBundleContext = bundleContext; } @@ -95,9 +65,12 @@ class BindingAwareBrokerImpl extends RpcProviderRegistryImpl implements BindingA private def createContext(BindingAwareProvider provider, BundleContext providerCtx) { new OsgiProviderContext(providerCtx, this) } + + override >> registerRouteChangeListener(L listener) { + super.registerRouteChangeListener(listener) + } override close() throws Exception { } - } \ No newline at end of file diff --git a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/RpcProviderRegistryImpl.java b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/RpcProviderRegistryImpl.java index bc862886d7..6a17007d22 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/RpcProviderRegistryImpl.java +++ b/opendaylight/md-sal/sal-binding-broker/src/main/java/org/opendaylight/controller/sal/binding/impl/RpcProviderRegistryImpl.java @@ -27,6 +27,8 @@ import org.opendaylight.yangtools.concepts.util.ListenerRegistry; import org.opendaylight.yangtools.yang.binding.BaseIdentity; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.opendaylight.yangtools.yang.binding.RpcService; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; import static com.google.common.base.Preconditions.*; @@ -41,6 +43,19 @@ public class RpcProviderRegistryImpl implements // private final ListenerRegistry>> routeChangeListeners = ListenerRegistry .create(); + private final static Logger LOG = LoggerFactory.getLogger(RpcProviderRegistryImpl.class); + + private final String name; + + public String getName() { + return name; + } + + public RpcProviderRegistryImpl(String name) { + super(); + this.name = name; + } + @Override public final RoutedRpcRegistration addRoutedRpcImplementation(Class type, T implementation) throws IllegalStateException { @@ -50,6 +65,7 @@ public class RpcProviderRegistryImpl implements // @Override public final RpcRegistration addRpcImplementation(Class type, T implementation) throws IllegalStateException { + @SuppressWarnings("unchecked") RpcRouter potentialRouter = (RpcRouter) rpcRouters.get(type); if (potentialRouter != null) { checkState(potentialRouter.getDefaultService() == null, @@ -59,20 +75,35 @@ public class RpcProviderRegistryImpl implements // T publicProxy = getRpcService(type); RpcService currentDelegate = RuntimeCodeHelper.getDelegate(publicProxy); checkState(currentDelegate == null, "Rpc service is already registered"); + LOG.debug("Registering {} as global implementation of {} in {}",implementation,type.getSimpleName(),this); RuntimeCodeHelper.setDelegate(publicProxy, implementation); return new RpcProxyRegistration(type, implementation, this); } + @SuppressWarnings("unchecked") @Override public final T getRpcService(Class type) { - RpcService potentialProxy = publicProxies.get(type); + @SuppressWarnings("unchecked") + T potentialProxy = (T) publicProxies.get(type); if (potentialProxy != null) { - return (T) potentialProxy; + return potentialProxy; + } + synchronized(this) { + /** + * Potential proxy could be instantiated by other thread while we were + * waiting for the lock. + */ + + potentialProxy = (T) publicProxies.get(type); + if (potentialProxy != null) { + return (T) potentialProxy; + } + T proxy = rpcFactory.getDirectProxyFor(type); + LOG.debug("Created {} as public proxy for {} in {}",proxy,type.getSimpleName(),this); + publicProxies.put(type, proxy); + return proxy; } - T proxy = rpcFactory.getDirectProxyFor(type); - publicProxies.put(type, proxy); - return proxy; } private RpcRouter getRpcRouter(Class type) { @@ -80,13 +111,25 @@ public class RpcProviderRegistryImpl implements // if (potentialRouter != null) { return (RpcRouter) potentialRouter; } - RpcRouter router = rpcFactory.getRouterFor(type); - router.registerRouteChangeListener(new RouteChangeForwarder(type)); - RuntimeCodeHelper.setDelegate(getRpcService(type), router.getInvocationProxy()); - rpcRouters.put(type, router); - return router; + synchronized(this) { + /** + * Potential Router could be instantiated by other thread while we were + * waiting for the lock. + */ + potentialRouter = rpcRouters.get(type); + if (potentialRouter != null) { + return (RpcRouter) potentialRouter; + } + RpcRouter router = rpcFactory.getRouterFor(type,name); + router.registerRouteChangeListener(new RouteChangeForwarder(type)); + LOG.debug("Registering router {} as global implementation of {} in {}",router,type.getSimpleName(),this); + RuntimeCodeHelper.setDelegate(getRpcService(type), router.getInvocationProxy()); + rpcRouters.put(type, router); + return router; + } } + @Override public >> ListenerRegistration registerRouteChangeListener( L listener) { return (ListenerRegistration) routeChangeListeners.register(listener); diff --git a/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/sal/binding/test/RuntimeCodeGeneratorTest.java b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/sal/binding/test/RuntimeCodeGeneratorTest.java index 9c9841a4a5..6f0db4cd8d 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/sal/binding/test/RuntimeCodeGeneratorTest.java +++ b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/sal/binding/test/RuntimeCodeGeneratorTest.java @@ -61,7 +61,7 @@ public class RuntimeCodeGeneratorTest { @Test public void testGenerateRouter() throws Exception { - RpcRouter product = codeGenerator.getRouterFor(FooService.class); + RpcRouter product = codeGenerator.getRouterFor(FooService.class,"test"); assertNotNull(product); assertNotNull(product.getInvocationProxy()); diff --git a/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/sal/binding/test/util/BindingTestContext.java b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/sal/binding/test/util/BindingTestContext.java index 3217a31329..d4d27a14ec 100644 --- a/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/sal/binding/test/util/BindingTestContext.java +++ b/opendaylight/md-sal/sal-binding-broker/src/test/java/org/opendaylight/controller/sal/binding/test/util/BindingTestContext.java @@ -110,7 +110,7 @@ public class BindingTestContext implements AutoCloseable { checkState(executor != null,"Executor needs to be set"); checkState(baDataImpl != null,"Binding Data Broker must be started"); checkState(baNotifyImpl != null, "Notification Service must be started"); - baBrokerImpl = new BindingAwareBrokerImpl(null); + baBrokerImpl = new BindingAwareBrokerImpl("test",null); baBrokerImpl.setDataBroker(baDataImpl); baBrokerImpl.setNotifyBroker(baNotifyImpl); diff --git a/opendaylight/md-sal/statistics-manager/src/main/java/org/opendaylight/controller/md/statistics/manager/StatisticsManagerActivator.java b/opendaylight/md-sal/statistics-manager/src/main/java/org/opendaylight/controller/md/statistics/manager/StatisticsManagerActivator.java index 521de7e394..738c2cb9a8 100644 --- a/opendaylight/md-sal/statistics-manager/src/main/java/org/opendaylight/controller/md/statistics/manager/StatisticsManagerActivator.java +++ b/opendaylight/md-sal/statistics-manager/src/main/java/org/opendaylight/controller/md/statistics/manager/StatisticsManagerActivator.java @@ -5,12 +5,7 @@ * terms of the Eclipse Public License v1.0 which accompanies this distribution, * and is available at http://www.eclipse.org/legal/epl-v10.html */ -/* - * TODO: Handle multipart messages with following flag true - * OFPMPF_REPLY_MORE = 1 << 0 - * Better accumulate all the messages and update local cache - * and configurational data store - */ + package org.opendaylight.controller.md.statistics.manager; import org.opendaylight.controller.sal.binding.api.AbstractBindingAwareProvider; diff --git a/opendaylight/md-sal/statistics-manager/src/main/java/org/opendaylight/controller/md/statistics/manager/StatisticsProvider.java b/opendaylight/md-sal/statistics-manager/src/main/java/org/opendaylight/controller/md/statistics/manager/StatisticsProvider.java index 95ba01cd54..19cf0ed386 100644 --- a/opendaylight/md-sal/statistics-manager/src/main/java/org/opendaylight/controller/md/statistics/manager/StatisticsProvider.java +++ b/opendaylight/md-sal/statistics-manager/src/main/java/org/opendaylight/controller/md/statistics/manager/StatisticsProvider.java @@ -44,8 +44,8 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111. import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.GetAllMeterStatisticsInputBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.GetAllMeterStatisticsOutput; import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.OpendaylightMeterStatisticsService; -import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.GetAllPortsStatisticsInputBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.GetAllPortsStatisticsOutput; +import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.GetAllNodeConnectorsStatisticsInputBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.GetAllNodeConnectorsStatisticsOutput; import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.OpendaylightPortStatisticsService; import org.opendaylight.yang.gen.v1.urn.opendaylight.queue.statistics.rev131216.GetAllQueuesStatisticsFromAllPortsInputBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.queue.statistics.rev131216.GetAllQueuesStatisticsFromAllPortsOutput; @@ -180,17 +180,13 @@ public class StatisticsProvider implements AutoCloseable { InstanceIdentifier targetInstanceId = InstanceIdentifier.builder(Nodes.class).child(Node.class,targetNode.getKey()).toInstance(); NodeRef targetNodeRef = new NodeRef(targetInstanceId); - System.out.println("ANIL: Target Node object ::"+targetNode.toString()); - - System.out.println("ANIL: FlowCapableNode augmentations ::"+targetNode.getAugmentation(FlowCapableNode.class)); - try { sendAggregateFlowsStatsFromAllTablesRequest(targetNode.getKey()); sendAllFlowsStatsFromAllTablesRequest(targetNodeRef); - sendAllPortStatisticsRequest(targetNodeRef); + sendAllNodeConnectorsStatisticsRequest(targetNodeRef); sendAllFlowTablesStatisticsRequest(targetNodeRef); @@ -206,13 +202,9 @@ public class StatisticsProvider implements AutoCloseable { try{ sendAllGroupStatisticsRequest(targetNodeRef); - Thread.sleep(1000); sendAllMeterStatisticsRequest(targetNodeRef); - Thread.sleep(1000); sendGroupDescriptionRequest(targetNodeRef); - Thread.sleep(1000); sendMeterConfigStatisticsRequest(targetNodeRef); - Thread.sleep(1000); }catch(Exception e){ spLogger.error("Exception occured while sending statistics requests : {}", e); } @@ -286,14 +278,14 @@ public class StatisticsProvider implements AutoCloseable { } - private void sendAllPortStatisticsRequest(NodeRef targetNode) throws InterruptedException, ExecutionException{ + private void sendAllNodeConnectorsStatisticsRequest(NodeRef targetNode) throws InterruptedException, ExecutionException{ - final GetAllPortsStatisticsInputBuilder input = new GetAllPortsStatisticsInputBuilder(); + final GetAllNodeConnectorsStatisticsInputBuilder input = new GetAllNodeConnectorsStatisticsInputBuilder(); input.setNode(targetNode); - Future> response = - portStatsService.getAllPortsStatistics(input.build()); + Future> response = + portStatsService.getAllNodeConnectorsStatistics(input.build()); this.multipartMessageManager.addTxIdToRequestTypeEntry(response.get().getResult().getTransactionId() , StatsRequestType.ALL_PORT); diff --git a/opendaylight/md-sal/statistics-manager/src/main/java/org/opendaylight/controller/md/statistics/manager/StatisticsUpdateCommiter.java b/opendaylight/md-sal/statistics-manager/src/main/java/org/opendaylight/controller/md/statistics/manager/StatisticsUpdateCommiter.java index edffb976c6..5c21fd6e10 100644 --- a/opendaylight/md-sal/statistics-manager/src/main/java/org/opendaylight/controller/md/statistics/manager/StatisticsUpdateCommiter.java +++ b/opendaylight/md-sal/statistics-manager/src/main/java/org/opendaylight/controller/md/statistics/manager/StatisticsUpdateCommiter.java @@ -29,10 +29,7 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.A import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.AggregateFlowStatisticsUpdate; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.FlowStatisticsData; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.FlowStatisticsDataBuilder; -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.FlowStatisticsUpdated; -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.FlowTableStatisticsUpdated; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.FlowsStatisticsUpdate; -import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.NodeConnectorStatisticsUpdated; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.OpendaylightFlowStatisticsListener; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.aggregate.flow.statistics.AggregateFlowStatisticsBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.flow.and.statistics.map.list.FlowAndStatisticsMapList; @@ -94,8 +91,8 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.model.statistics.types.rev1 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.statistics.types.rev130925.GenericStatistics; import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.FlowCapableNodeConnectorStatisticsData; import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.FlowCapableNodeConnectorStatisticsDataBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.NodeConnectorStatisticsUpdate; import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.OpendaylightPortStatisticsListener; -import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.PortStatisticsUpdate; import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.flow.capable.node.connector.statistics.FlowCapableNodeConnectorStatisticsBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.node.connector.statistics.and.port.number.map.NodeConnectorStatisticsAndPortNumberMap; import org.opendaylight.yang.gen.v1.urn.opendaylight.queue.statistics.rev131216.FlowCapableNodeConnectorQueueStatisticsData; @@ -554,7 +551,7 @@ public class StatisticsUpdateCommiter implements OpendaylightGroupStatisticsList } @Override - public void onPortStatisticsUpdate(PortStatisticsUpdate notification) { + public void onNodeConnectorStatisticsUpdate(NodeConnectorStatisticsUpdate notification) { //Check if response is for the request statistics-manager sent. if(this.statisticsManager.getMultipartMessageManager().removeTxId(notification.getTransactionId()) == null) return; @@ -714,28 +711,6 @@ public class StatisticsUpdateCommiter implements OpendaylightGroupStatisticsList } - @Override - public void onFlowStatisticsUpdated(FlowStatisticsUpdated notification) { - // TODO Auto-generated method stub - //TODO: Depricated, will clean it up once sal-compatibility is fixed. - //Sal-Compatibility code usage this notification event. - - } - - @Override - public void onFlowTableStatisticsUpdated(FlowTableStatisticsUpdated notification) { - // TODO Auto-generated method stub - //TODO: Need to implement it yet - - } - - @Override - public void onNodeConnectorStatisticsUpdated(NodeConnectorStatisticsUpdated notification) { - // TODO Auto-generated method stub - //TODO: Need to implement it yet - - } - private NodeRef getNodeRef(NodeKey nodeKey){ InstanceIdentifierBuilder builder = InstanceIdentifier.builder(Nodes.class).child(Node.class, nodeKey); return new NodeRef(builder.toInstance()); diff --git a/opendaylight/netconf/netconf-util/src/main/java/org/opendaylight/controller/netconf/util/AbstractNetconfSessionNegotiator.java b/opendaylight/netconf/netconf-util/src/main/java/org/opendaylight/controller/netconf/util/AbstractNetconfSessionNegotiator.java index e30ce5b47e..4fee930eff 100644 --- a/opendaylight/netconf/netconf-util/src/main/java/org/opendaylight/controller/netconf/util/AbstractNetconfSessionNegotiator.java +++ b/opendaylight/netconf/netconf-util/src/main/java/org/opendaylight/controller/netconf/util/AbstractNetconfSessionNegotiator.java @@ -124,8 +124,9 @@ public abstract class AbstractNetconfSessionNegotiator

bwThresholdFactor * bw) { - if (!connectorsOverUtilized.contains(connector)) { - connectorsOverUtilized.add(connector); - this.bwUtilNotifyQ.add(new UtilizationUpdate(connector, - UpdateType.ADDED)); - } - } else { - if (connectorsOverUtilized.contains(connector)) { - connectorsOverUtilized.remove(connector); - this.bwUtilNotifyQ.add(new UtilizationUpdate(connector, - UpdateType.REMOVED)); + if (statsMgr != null) { + float rate = statsMgr.getTransmitRate(switchId, port); + if (rate > bwThresholdFactor * bw) { + if (!connectorsOverUtilized.contains(connector)) { + connectorsOverUtilized.add(connector); + this.bwUtilNotifyQ.add(new UtilizationUpdate(connector, UpdateType.ADDED)); + } + } else { + if (connectorsOverUtilized.contains(connector)) { + connectorsOverUtilized.remove(connector); + this.bwUtilNotifyQ.add(new UtilizationUpdate(connector, UpdateType.REMOVED)); + } } } } diff --git a/opendaylight/switchmanager/api/src/main/java/org/opendaylight/controller/switchmanager/Subnet.java b/opendaylight/switchmanager/api/src/main/java/org/opendaylight/controller/switchmanager/Subnet.java index 16c09fe3f6..56df8e26bd 100644 --- a/opendaylight/switchmanager/api/src/main/java/org/opendaylight/controller/switchmanager/Subnet.java +++ b/opendaylight/switchmanager/api/src/main/java/org/opendaylight/controller/switchmanager/Subnet.java @@ -161,15 +161,11 @@ public class Subnet implements Cloneable, Serializable { } InetAddress thisPrefix = getPrefixForAddress(this.networkAddress); InetAddress otherPrefix = getPrefixForAddress(ip); - if ((thisPrefix == null) || (otherPrefix == null)) { - return false; - } - if (thisPrefix.equals(otherPrefix)) { - return true; - } - else { - return false; + boolean isSubnetOf = true; + if (((thisPrefix == null) || (otherPrefix == null)) || (!thisPrefix.equals(otherPrefix)) ) { + isSubnetOf = false; } + return isSubnetOf; } public short getVlan() { @@ -248,17 +244,7 @@ public class Subnet implements Cloneable, Serializable { } public boolean isMutualExclusive(Subnet otherSubnet) { - if (this.networkAddress.getClass() != otherSubnet.networkAddress - .getClass()) { - return true; - } - if (this.isSubnetOf(otherSubnet.getNetworkAddress())) { - return false; - } - if (otherSubnet.isSubnetOf(this.getNetworkAddress())) { - return false; - } - return true; + return !(isSubnetOf(otherSubnet.getNetworkAddress()) || otherSubnet.isSubnetOf(getNetworkAddress())); } /** diff --git a/opendaylight/switchmanager/api/src/test/java/org/opendaylight/controller/switchmanager/SubnetTest.java b/opendaylight/switchmanager/api/src/test/java/org/opendaylight/controller/switchmanager/SubnetTest.java index 41a1f1ab06..8b6a149917 100644 --- a/opendaylight/switchmanager/api/src/test/java/org/opendaylight/controller/switchmanager/SubnetTest.java +++ b/opendaylight/switchmanager/api/src/test/java/org/opendaylight/controller/switchmanager/SubnetTest.java @@ -8,8 +8,13 @@ package org.opendaylight.controller.switchmanager; +import static org.junit.Assert.fail; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + import java.net.Inet6Address; import java.net.InetAddress; +import java.net.UnknownHostException; import java.util.HashSet; import java.util.Set; @@ -26,19 +31,19 @@ public class SubnetTest { public void testSubnet() throws Exception { InetAddress ipaddr = InetAddress.getByName("100.0.0.1"); Subnet subnet = new Subnet(ipaddr, (short) 24, (short) 5); - Assert.assertTrue(subnet.equals(subnet)); - Assert.assertFalse(subnet.equals(null)); - Assert.assertFalse(subnet.equals(ipaddr)); + assertTrue(subnet.equals(subnet)); + assertFalse(subnet.equals(null)); + assertFalse(subnet.equals(ipaddr)); Subnet subnet2 = new Subnet(ipaddr, (short) 24, (short) 5); Inet6Address ipv6 = (Inet6Address) Inet6Address .getByName("1111::2222:3333:4444:5555:6666"); Subnet subnet3 = new Subnet(ipv6, (short) 24, (short) 5); - Assert.assertTrue(subnet.equals(subnet2)); - Assert.assertFalse(subnet.isMutualExclusive(subnet2)); - Assert.assertTrue(subnet.isMutualExclusive(subnet3)); + assertTrue(subnet.equals(subnet2)); + assertFalse(subnet.isMutualExclusive(subnet2)); + assertTrue(subnet.isMutualExclusive(subnet3)); InetAddress subnetAddr = InetAddress.getByName("200.0.0.100"); - Assert.assertTrue(subnet.isFlatLayer2() == true); + assertTrue(subnet.isFlatLayer2() == true); Set ncSet = new HashSet(); Node node = NodeCreator.createOFNode(((long) 10)); @@ -53,10 +58,10 @@ public class SubnetTest { ncSet.add(nc1); ncSet.add(nc2); - Assert.assertTrue(subnet.hasNodeConnector(nc0)); - Assert.assertFalse(subnet.hasNodeConnector(null)); + assertTrue(subnet.hasNodeConnector(nc0)); + assertFalse(subnet.hasNodeConnector(null)); subnet.addNodeConnectors(ncSet); - Assert.assertTrue(subnet.hasNodeConnector(nc0)); + assertTrue(subnet.hasNodeConnector(nc0)); Set resultncSet = subnet.getNodeConnectors(); Assert.assertEquals(resultncSet, ncSet); @@ -69,24 +74,61 @@ public class SubnetTest { Set ncSet2 = new HashSet(); ncSet2.add(nc0); subnet.deleteNodeConnectors(ncSet2); - Assert.assertFalse(subnet.getNodeConnectors().contains(nc0)); - Assert.assertFalse(subnet.hasNodeConnector(nc0)); - Assert.assertTrue(subnet.getNodeConnectors().contains(nc1)); - Assert.assertTrue(subnet.getNodeConnectors().contains(nc2)); + assertFalse(subnet.getNodeConnectors().contains(nc0)); + assertFalse(subnet.hasNodeConnector(nc0)); + assertTrue(subnet.getNodeConnectors().contains(nc1)); + assertTrue(subnet.getNodeConnectors().contains(nc2)); subnet.deleteNodeConnectors(ncSet2); subnet.setNetworkAddress(subnetAddr); - Assert.assertTrue(subnet.isMutualExclusive(subnet2)); - Assert.assertTrue(subnet.getNetworkAddress().equals(subnetAddr)); + assertTrue(subnet.isMutualExclusive(subnet2)); + assertTrue(subnet.getNetworkAddress().equals(subnetAddr)); subnet.setSubnetMaskLength((short) 16); - Assert.assertTrue(subnet.getSubnetMaskLength() == 16); + assertTrue(subnet.getSubnetMaskLength() == 16); subnet.setVlan((short) 100); - Assert.assertTrue(subnet.getVlan() == 100); + assertTrue(subnet.getVlan() == 100); + + assertTrue(subnet.isFlatLayer2() == false); + } + + @Test + public void checkIsSubnetOfComparisonMatch() { + String host = "10.0.0.1"; + InetAddress ipAddrForSubnetComparison = null; + try { + ipAddrForSubnetComparison = InetAddress.getByName(host); + } catch (UnknownHostException e) { + fail("Failed to create InetAddress object for" + host); + } + SubnetConfig subnetConf = new SubnetConfig("subnet", "10.0.0.254/24",null); + Subnet subnet = new Subnet(subnetConf); + assertTrue(subnet.isSubnetOf(ipAddrForSubnetComparison)); + } - Assert.assertTrue(subnet.isFlatLayer2() == false); + @Test + public void checkIsSubnetOfComparisonNoMatch() { + String host = "100.0.0.1"; + InetAddress ipAddrForSubnetComparison = null; + try { + ipAddrForSubnetComparison = InetAddress.getByName(host); + } catch (UnknownHostException e) { + fail("Failed to create InetAddress object for" + host); + } + SubnetConfig subnetConf = new SubnetConfig("subnet", "10.0.0.254/24",null); + Subnet subnet = new Subnet(subnetConf); + assertFalse(subnet.isSubnetOf(ipAddrForSubnetComparison)); + } + + @Test + public void checkIsSubnetOfComparisonIpEmpty() { + SubnetConfig subnetConf = new SubnetConfig("subnet", "10.0.0.254/24",null); + Subnet subnet = new Subnet(subnetConf); + assertFalse(subnet.isSubnetOf(null)); } + + }