<artifactId>groupbasedpolicy</artifactId>
<version>${project.version}</version>
</dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>l2-l3-domain-extension</artifactId>
+ <version>${project.version}</version>
+ </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>ofoverlay-renderer</artifactId>
<artifactId>neutron-mapper</artifactId>
<version>${project.version}</version>
</dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>neutron-vpp-mapper</artifactId>
+ <version>${project.version}</version>
+ </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>neutron-ovsdb</artifactId>
<type>xml</type>
<classifier>config</classifier>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.groupbasedpolicy</groupId>
+ <artifactId>l2-l3-domain-extension</artifactId>
+ <version>${project.version}</version>
+ <type>xml</type>
+ <classifier>config</classifier>
+ </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>ofoverlay-renderer</artifactId>
<type>xml</type>
<classifier>config</classifier>
</dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>neutron-vpp-mapper</artifactId>
+ <version>${project.version}</version>
+ <type>xml</type>
+ <classifier>config</classifier>
+ </dependency>
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>neutron-ovsdb</artifactId>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Copyright (c) 2016 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 -->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.opendaylight.groupbasedpolicy</groupId>
+ <artifactId>groupbasedpolicy-domain-extensions</artifactId>
+ <version>0.4.0-SNAPSHOT</version>
+ <relativePath>../</relativePath>
+ </parent>
+
+ <artifactId>l2-l3-domain-extension</artifactId>
+ <packaging>bundle</packaging>
+
+ <dependencies>
+ <!-- testing dependencies -->
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.mockito</groupId>
+ <artifactId>mockito-all</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal-binding-broker-impl</artifactId>
+ <type>test-jar</type>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.groupbasedpolicy</groupId>
+ <artifactId>groupbasedpolicy</artifactId>
+ <version>${project.version}</version>
+ <type>test-jar</type>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.powermock</groupId>
+ <artifactId>powermock-module-junit4</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.powermock</groupId>
+ <artifactId>powermock-api-mockito</artifactId>
+ <scope>test</scope>
+ </dependency>
+ </dependencies>
+
+ <!-- project build -->
+ <build>
+ <!-- We use the maven-resources-plugin to copy a class from the groupbasepolicy
+ bundle that we need in order to run some unit tests in the renderer (classes
+ in the test directory aren't packaged in bundles, and instead of keeping
+ separate copies, we just copy the file(s) needed in order to run the test). -->
+ <plugins>
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-bundle-plugin</artifactId>
+ <extensions>true</extensions>
+ <configuration>
+ <instructions>
+ <Export-Package>
+ org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.*,
+ org.opendaylight.groupbasedpolicy.domain_extension.l2_l3.util
+ </Export-Package>
+ </instructions>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+</project>
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- vi: set et smarttab sw=4 tabstop=4: -->
+<!--
+ Copyright (c) 2016 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
+-->
+<snapshot>
+ <configuration>
+ <data xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
+ <modules xmlns="urn:opendaylight:params:xml:ns:yang:controller:config">
+ <module>
+ <type xmlns:l2l3="urn:opendaylight:params:xml:ns:yang:controller:config:domain_extension:l2_l3:impl">
+ l2l3:l2-l3-domain-extension-impl
+ </type>
+ <name>l2-l3-domain-extension-impl</name>
+
+ <domain-specific-registry>
+ <type xmlns:gbp="urn:opendaylight:params:xml:ns:yang:controller:config:groupbasedpolicy">gbp:domain-specific-registry</type>
+ <name>domain-specific-registry</name>
+ </domain-specific-registry>
+ </module>
+ </modules>
+ </data>
+
+ </configuration>
+
+ <required-capabilities>
+ <capability>urn:opendaylight:params:xml:ns:yang:controller:config:domain_extension:l2_l3:impl?module=l2-l3-domain-extension-cfg&revision=2016-05-25</capability>
+ </required-capabilities>
+
+</snapshot>
--- /dev/null
+/*
+ * Copyright (c) 2016 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.config.domain_extension.l2_l3.impl;
+
+import org.opendaylight.groupbasedpolicy.api.DomainSpecificRegistry;
+import org.opendaylight.groupbasedpolicy.domain_extension.l2_l3.L2L3NetworkDomainAugmentor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.Preconditions;
+
+public class L2L3DomainExtensionModule extends org.opendaylight.controller.config.yang.config.domain_extension.l2_l3.impl.AbstractL2L3DomainExtensionModule {
+
+ private static final Logger LOG = LoggerFactory.getLogger(L2L3DomainExtensionModule.class);
+
+ public L2L3DomainExtensionModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) {
+ super(identifier, dependencyResolver);
+ }
+
+ public L2L3DomainExtensionModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver, org.opendaylight.controller.config.yang.config.domain_extension.l2_l3.impl.L2L3DomainExtensionModule oldModule, java.lang.AutoCloseable oldInstance) {
+ super(identifier, dependencyResolver, oldModule, oldInstance);
+ }
+
+ @Override
+ public void customValidation() {
+ // add custom validation form module attributes here.
+ }
+
+ @Override
+ public java.lang.AutoCloseable createInstance() {
+ DomainSpecificRegistry domainSpecificRegistry = getDomainSpecificRegistryDependency();
+ Preconditions.checkNotNull(domainSpecificRegistry);
+ L2L3NetworkDomainAugmentor l2l3NetworkDomainAugmentor =
+ new L2L3NetworkDomainAugmentor(domainSpecificRegistry.getNetworkDomainAugmentorRegistry());
+ LOG.info("{} successfully started.", L2L3DomainExtensionModule.class.getCanonicalName());
+ return l2l3NetworkDomainAugmentor;
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 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.config.domain_extension.l2_l3.impl;
+public class L2L3DomainExtensionModuleFactory extends org.opendaylight.controller.config.yang.config.domain_extension.l2_l3.impl.AbstractL2L3DomainExtensionModuleFactory {
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 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.groupbasedpolicy.domain_extension.l2_l3;
+
+import java.util.AbstractMap.SimpleImmutableEntry;
+import java.util.Map.Entry;
+
+import org.opendaylight.groupbasedpolicy.api.NetworkDomainAugmentor;
+import org.opendaylight.groupbasedpolicy.api.NetworkDomainAugmentorRegistry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.SubnetAugmentForwarding;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.SubnetAugmentRenderer;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.SubnetAugmentRendererBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.NetworkDomain;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.forwarding.renderer.forwarding.by.tenant.RendererNetworkDomain;
+import org.opendaylight.yangtools.yang.binding.Augmentation;
+
+import com.google.common.base.Preconditions;
+
+public class L2L3NetworkDomainAugmentor implements NetworkDomainAugmentor, AutoCloseable {
+
+ private final NetworkDomainAugmentorRegistry networkDomainAugmentorRegistry;
+
+ public L2L3NetworkDomainAugmentor(NetworkDomainAugmentorRegistry networkDomainAugmentorRegistry) {
+ this.networkDomainAugmentorRegistry = Preconditions.checkNotNull(networkDomainAugmentorRegistry);
+ this.networkDomainAugmentorRegistry.register(this);
+ }
+
+ @Override
+ public Entry<Class<? extends Augmentation<RendererNetworkDomain>>, Augmentation<RendererNetworkDomain>> buildRendererNetworkDomainAugmentation(
+ NetworkDomain input) {
+ SubnetAugmentForwarding subnetForwarding = input.getAugmentation(SubnetAugmentForwarding.class);
+ if (subnetForwarding == null) {
+ return null;
+ }
+ return new SimpleImmutableEntry<>(SubnetAugmentRenderer.class,
+ new SubnetAugmentRendererBuilder(subnetForwarding).build());
+ }
+
+ @Override
+ public void close() throws Exception {
+ networkDomainAugmentorRegistry.unregister(this);
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 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.groupbasedpolicy.domain_extension.l2_l3.util;
+
+import org.opendaylight.groupbasedpolicy.util.IidFactory;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContextId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.NetworkDomainId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L2BridgeDomain;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L2FloodDomain;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.Subnet;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.ForwardingContext;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.ForwardingContextKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.NetworkDomain;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.NetworkDomainKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class L2L3IidFactory {
+
+ public static InstanceIdentifier<NetworkDomain> subnetIid(TenantId tenantId, NetworkDomainId id) {
+ NetworkDomainKey domainKey = new NetworkDomainKey(id, Subnet.class);
+ return IidFactory.forwardingByTenantIid(tenantId).child(NetworkDomain.class, domainKey);
+ }
+
+ public static InstanceIdentifier<ForwardingContext> l2FloodDomainIid(TenantId tenantId, ContextId id) {
+ ForwardingContextKey domainKey = new ForwardingContextKey(id, L2FloodDomain.class);
+ return IidFactory.forwardingByTenantIid(tenantId).child(ForwardingContext.class, domainKey);
+ }
+
+ public static InstanceIdentifier<ForwardingContext> l2BridgeDomainIid(TenantId tenantId, ContextId id) {
+ ForwardingContextKey domainKey = new ForwardingContextKey(id, L2BridgeDomain.class);
+ return IidFactory.forwardingByTenantIid(tenantId).child(ForwardingContext.class, domainKey);
+ }
+
+ public static InstanceIdentifier<ForwardingContext> l3ContextIid(TenantId tenantId, ContextId id) {
+ ForwardingContextKey domainKey = new ForwardingContextKey(id, L3Context.class);
+ return IidFactory.forwardingByTenantIid(tenantId).child(ForwardingContext.class, domainKey);
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 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
+ */
+
+module l2-l3-domain-extension-cfg {
+ yang-version 1;
+ namespace "urn:opendaylight:params:xml:ns:yang:controller:config:domain_extension:l2_l3:impl";
+ prefix "gbpcfg";
+
+ import config { prefix config; revision-date 2013-04-05; }
+ import opendaylight-md-sal-binding { prefix mdsal; revision-date 2013-10-28; }
+ import groupbasedpolicy-cfg { prefix gbpcfg; revision-date 2015-11-06; }
+
+ description
+ "This module contains the base YANG definitions for
+ l2-l3 domain exstension implementation.";
+
+ revision "2016-05-25" {
+ description
+ "Initial revision.";
+ }
+
+ identity l2-l3-domain-extension-impl {
+ base "config:module-type";
+
+ config:java-name-prefix L2L3DomainExtension;
+ }
+
+ // Augments the 'configuration' choice node under modules/module.
+ augment "/config:modules/config:module/config:configuration" {
+ case l2-l3-domain-extension-impl {
+ when "/config:modules/config:module/config:type = 'l2-l3-domain-extension-impl'";
+
+ // DomainSpecificRegistry service
+ container domain-specific-registry {
+ uses config:service-ref {
+ refine type {
+ config:required-identity gbpcfg:domain-specific-registry;
+ }
+ }
+ }
+ }
+ }
+}
--- /dev/null
+package org.opendaylight.groupbasedpolicy.domain_extension.l2_l3;
+
+import java.util.Arrays;
+import java.util.Map.Entry;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.opendaylight.groupbasedpolicy.api.NetworkDomainAugmentorRegistry;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Prefix;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.NetworkDomainId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.SubnetAugmentForwarding;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.SubnetAugmentForwardingBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.SubnetAugmentRenderer;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.has.subnet.SubnetBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.has.subnet.subnet.Gateways;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.has.subnet.subnet.GatewaysBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.has.subnet.subnet.gateways.PrefixesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.NetworkDomain;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.NetworkDomainBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.renderer.forwarding.renderer.forwarding.by.tenant.RendererNetworkDomain;
+import org.opendaylight.yangtools.yang.binding.Augmentation;
+
+@RunWith(MockitoJUnitRunner.class)
+public class L2L3NetworkDomainAugmentorTest {
+
+ private static final IpPrefix IP_PREFIX = new IpPrefix(new Ipv4Prefix("1.1.1.1/24"));
+ private static final IpPrefix IP_PREFIX_2 = new IpPrefix(new Ipv4Prefix("2.2.2.2/24"));
+ private static final IpAddress IP_ADDRESS = new IpAddress(new Ipv4Address("1.1.1.1"));
+ private static final IpAddress IP_ADDRESS_2 = new IpAddress(new Ipv4Address("2.2.2.2"));
+ private static final NetworkDomainId NET_DOMAIN = new NetworkDomainId("netDomain1");
+
+ @Rule
+ public ExpectedException exception = ExpectedException.none();
+ @Mock
+ private NetworkDomainAugmentorRegistry networkDomainAugmentorRegistry;
+
+ private L2L3NetworkDomainAugmentor l2l3Augmentor;
+
+ @Before
+ public void init() {
+ l2l3Augmentor = new L2L3NetworkDomainAugmentor(networkDomainAugmentorRegistry);
+ }
+
+ @Test
+ public void testConstructor() {
+ L2L3NetworkDomainAugmentor l2l3NetworkDomainAugmentor =
+ new L2L3NetworkDomainAugmentor(networkDomainAugmentorRegistry);
+ Mockito.verify(networkDomainAugmentorRegistry).register(Mockito.eq(l2l3NetworkDomainAugmentor));
+ }
+
+ @Test
+ public void testConstructor_npe_exception() {
+ exception.expect(NullPointerException.class);
+ new L2L3NetworkDomainAugmentor(null);
+ }
+
+ @Test
+ public void testClose() throws Exception {
+ l2l3Augmentor.close();
+ Mockito.verify(networkDomainAugmentorRegistry).register(Mockito.eq(l2l3Augmentor));
+ }
+
+ @Test
+ public void testBuildRendererNetworkDomainAugmentation() {
+ Gateways gateways = new GatewaysBuilder().setGateway(IP_ADDRESS)
+ .setPrefixes(Arrays.asList(new PrefixesBuilder().setPrefix(IP_PREFIX_2).build()))
+ .build();
+ SubnetAugmentForwarding subnetAugmentForwarding =
+ new SubnetAugmentForwardingBuilder().setSubnet(new SubnetBuilder().setIpPrefix(IP_PREFIX)
+ .setGateways(Arrays.asList(gateways))
+ .setVirtualRouterIp(IP_ADDRESS_2)
+ .build()).build();
+ NetworkDomain networkDomain = new NetworkDomainBuilder()
+ .setNetworkDomainType(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.NetworkDomain.class)
+ .setNetworkDomainId(NET_DOMAIN)
+ .addAugmentation(SubnetAugmentForwarding.class, subnetAugmentForwarding)
+ .build();
+
+ Entry<Class<? extends Augmentation<RendererNetworkDomain>>, Augmentation<RendererNetworkDomain>> rendererNetworkDomainAugmentation =
+ l2l3Augmentor.buildRendererNetworkDomainAugmentation(networkDomain);
+
+ Assert.assertNotNull(rendererNetworkDomainAugmentation);
+ Assert.assertEquals(SubnetAugmentRenderer.class, rendererNetworkDomainAugmentation.getKey());
+ Augmentation<RendererNetworkDomain> rendererNetDomainAug = rendererNetworkDomainAugmentation.getValue();
+ Assert.assertTrue(rendererNetDomainAug instanceof SubnetAugmentRenderer);
+ SubnetAugmentRenderer subnetAugmentRenderer = (SubnetAugmentRenderer) rendererNetDomainAug;
+ Assert.assertEquals(subnetAugmentForwarding.getSubnet(), subnetAugmentRenderer.getSubnet());
+ }
+
+ @Test
+ public void testBuildRendererNetworkDomainAugmentation_nullAugmentation() {
+ NetworkDomain networkDomain = new NetworkDomainBuilder()
+ .setNetworkDomainType(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.NetworkDomain.class)
+ .setNetworkDomainId(NET_DOMAIN)
+ .build();
+
+ Entry<Class<? extends Augmentation<RendererNetworkDomain>>, Augmentation<RendererNetworkDomain>> rendererNetworkDomainAugmentation =
+ l2l3Augmentor.buildRendererNetworkDomainAugmentation(networkDomain);
+
+ Assert.assertNull(rendererNetworkDomainAugmentation);
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 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.groupbasedpolicy.domain_extension.l2_l3.util;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContextId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.ForwardingByTenant;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.ForwardingContext;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.NetworkDomain;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class L2L3IidFactoryTest {
+
+ private static final TenantId TENANT_ID = new TenantId("t1");
+ private static final ContextId CONTEXT_ID = new ContextId("ctx1");
+
+ @Test
+ public void testL2FloodDomainIid() {
+ InstanceIdentifier<ForwardingContext> identifier = L2L3IidFactory.l2FloodDomainIid(TENANT_ID, CONTEXT_ID);
+ Assert.assertEquals(CONTEXT_ID, InstanceIdentifier.keyOf(identifier).getContextId());
+ Assert.assertEquals(TENANT_ID, identifier.firstKeyOf(ForwardingByTenant.class).getTenantId());
+ }
+
+ @Test
+ public void testL2BridgeDomainIid() {
+ InstanceIdentifier<ForwardingContext> identifier = L2L3IidFactory.l2BridgeDomainIid(TENANT_ID, CONTEXT_ID);
+ Assert.assertEquals(CONTEXT_ID, InstanceIdentifier.keyOf(identifier).getContextId());
+ Assert.assertEquals(TENANT_ID, identifier.firstKeyOf(ForwardingByTenant.class).getTenantId());
+ }
+
+ @Test
+ public void testL3ContextIid() {
+ InstanceIdentifier<ForwardingContext> identifier = L2L3IidFactory.l3ContextIid(TENANT_ID, CONTEXT_ID);
+ Assert.assertEquals(CONTEXT_ID, InstanceIdentifier.keyOf(identifier).getContextId());
+ Assert.assertEquals(TENANT_ID, identifier.firstKeyOf(ForwardingByTenant.class).getTenantId());
+ }
+
+ @Test
+ public void testSubnetIid() {
+ InstanceIdentifier<NetworkDomain> identifier = L2L3IidFactory.subnetIid(TENANT_ID, CONTEXT_ID);
+ Assert.assertEquals(TENANT_ID, identifier.firstKeyOf(ForwardingByTenant.class).getTenantId());
+ Assert.assertEquals(CONTEXT_ID, identifier.firstKeyOf(NetworkDomain.class).getNetworkDomainId());
+ }
+}
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Copyright (c) 2016 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 -->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>config-parent</artifactId>
+ <version>0.5.0-SNAPSHOT</version>
+ <relativePath/>
+ </parent>
+
+ <groupId>org.opendaylight.groupbasedpolicy</groupId>
+ <artifactId>groupbasedpolicy-domain-extensions</artifactId>
+ <version>0.4.0-SNAPSHOT</version>
+ <packaging>pom</packaging>
+
+ <modules>
+ <module>l2-l3</module>
+ </modules>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.opendaylight.groupbasedpolicy</groupId>
+ <artifactId>groupbasedpolicy</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ </dependencies>
+</project>
<groupId>org.opendaylight.groupbasedpolicy</groupId>
<artifactId>groupbasedpolicy</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.groupbasedpolicy</groupId>
+ <artifactId>l2-l3-domain-extension</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.groupbasedpolicy</groupId>
<artifactId>ofoverlay-renderer</artifactId>
<groupId>org.opendaylight.groupbasedpolicy</groupId>
<artifactId>neutron-mapper</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.groupbasedpolicy</groupId>
+ <artifactId>neutron-vpp-mapper</artifactId>
+ </dependency>
<dependency>
<groupId>org.opendaylight.groupbasedpolicy</groupId>
<artifactId>neutron-ovsdb</artifactId>
<type>xml</type>
<classifier>config</classifier>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.groupbasedpolicy</groupId>
+ <artifactId>l2-l3-domain-extension</artifactId>
+ <type>xml</type>
+ <classifier>config</classifier>
+ </dependency>
<dependency>
<groupId>org.opendaylight.groupbasedpolicy</groupId>
<artifactId>ofoverlay-renderer</artifactId>
<type>xml</type>
<classifier>config</classifier>
</dependency>
+ <dependency>
+ <groupId>org.opendaylight.groupbasedpolicy</groupId>
+ <artifactId>neutron-vpp-mapper</artifactId>
+ <type>xml</type>
+ <classifier>config</classifier>
+ </dependency>
<dependency>
<groupId>org.opendaylight.groupbasedpolicy</groupId>
<artifactId>neutron-ovsdb</artifactId>
<feature name='odl-groupbasedpolicy-neutronmapper' version='${project.version}' description='OpenDaylight :: groupbasedpolicy :: Neutron Mapper mapps neutron APIs to GBP APIs '>
<feature version="${neutron.version}">odl-neutron-service</feature>
<feature version="${project.version}">odl-groupbasedpolicy-base</feature>
+ <bundle>mvn:org.opendaylight.groupbasedpolicy/l2-l3-domain-extension/{{VERSION}}</bundle>
<bundle>mvn:org.opendaylight.neutron/dummyprovider/{{VERSION}}</bundle>
<bundle>mvn:org.opendaylight.groupbasedpolicy/neutron-mapper/{{VERSION}}</bundle>
+ <configfile finalname="${config.configfile.directory}/15-l2-l3-domain-extension.xml">mvn:org.opendaylight.groupbasedpolicy/l2-l3-domain-extension/{{VERSION}}/xml/config</configfile>
<configfile finalname="${config.configfile.directory}/15-neutron-mapper.xml">mvn:org.opendaylight.groupbasedpolicy/neutron-mapper/{{VERSION}}/xml/config</configfile>
</feature>
-->
<feature name='odl-groupbasedpolicy-vpp' version='${project.version}' description='OpenDaylight :: groupbasedpolicy :: VPP renderer '>
<feature version="${project.version}">odl-groupbasedpolicy-base</feature>
+ <feature version="${netconf.version}">odl-netconf-topology</feature>
+ <bundle>mvn:org.opendaylight.groupbasedpolicy/l2-l3-domain-extension/{{VERSION}}</bundle>
<bundle>mvn:org.opendaylight.groupbasedpolicy/vpp-renderer/{{VERSION}}</bundle>
+ <configfile finalname="${config.configfile.directory}/15-l2-l3-domain-extension.xml">mvn:org.opendaylight.groupbasedpolicy/l2-l3-domain-extension/{{VERSION}}/xml/config</configfile>
<configfile finalname="${config.configfile.directory}/15-vpp-renderer.xml">mvn:org.opendaylight.groupbasedpolicy/vpp-renderer/{{VERSION}}/xml/config</configfile>
</feature>
+ <!--
+ The Neutron-VPP provider
+ -->
+ <feature name='odl-groupbasedpolicy-neutron-vpp-mapper' version='${project.version}' description='OpenDaylight :: groupbasedpolicy :: Neutron Mapper mapps neutron APIs to GBP APIs '>
+ <feature version="${project.version}">odl-groupbasedpolicy-neutronmapper</feature>
+ <feature version="${project.version}">odl-groupbasedpolicy-vpp</feature>
+ <bundle>mvn:org.opendaylight.groupbasedpolicy/neutron-vpp-mapper/{{VERSION}}</bundle>
+ <configfile finalname="${config.configfile.directory}/15-neutron-vpp-mapper.xml">mvn:org.opendaylight.groupbasedpolicy/neutron-vpp-mapper/{{VERSION}}/xml/config</configfile>
+ </feature>
+
<!--
The UI Backend
-->
<feature name='odl-groupbasedpolicy-sxp-mapper' version='${project.version}' description='OpenDaylight :: groupbasedpolicy :: sxp-mapper'>
<feature version="${project.version}">odl-groupbasedpolicy-base</feature>
<feature version="${sxp.version}">odl-sxp-core</feature>
+ <bundle>mvn:org.opendaylight.groupbasedpolicy/l2-l3-domain-extension/{{VERSION}}</bundle>
<bundle>mvn:commons-net/commons-net/{{VERSION}}</bundle>
<bundle>mvn:org.opendaylight.groupbasedpolicy/sxp-mapper/{{VERSION}}</bundle>
+ <configfile finalname="${config.configfile.directory}/15-l2-l3-domain-extension.xml">mvn:org.opendaylight.groupbasedpolicy/l2-l3-domain-extension/{{VERSION}}/xml/config</configfile>
<configfile finalname="${config.configfile.directory}/15-groupbasedpolicy-sxp-mapper.xml">mvn:org.opendaylight.groupbasedpolicy/sxp-mapper/{{VERSION}}/xml/config</configfile>
</feature>
-->
<feature name='odl-groupbasedpolicy-ne-location-provider' version='${project.version}' description='OpenDaylight :: groupbasedpolicy :: NE location provider'>
<feature version="${project.version}">odl-groupbasedpolicy-base</feature>
+ <bundle>mvn:org.opendaylight.groupbasedpolicy/l2-l3-domain-extension/{{VERSION}}</bundle>
<bundle>mvn:org.opendaylight.groupbasedpolicy/ne-location-provider/{{VERSION}}</bundle>
+ <configfile finalname="${config.configfile.directory}/15-l2-l3-domain-extension.xml">mvn:org.opendaylight.groupbasedpolicy/l2-l3-domain-extension/{{VERSION}}/xml/config</configfile>
<configfile finalname="${config.configfile.directory}/15-ne-location-provider.xml">mvn:org.opendaylight.groupbasedpolicy/ne-location-provider/{{VERSION}}/xml/config</configfile>
</feature>
<!--
IOS-XE renderer
- -->
+ -->
<feature name='odl-groupbasedpolicy-ios-xe' version='${project.version}' description='OpenDaylight :: groupbasedpolicy :: ios-xe renderer'>
<feature version="${project.version}">odl-groupbasedpolicy-base</feature>
<feature version="${sfc.version}">odl-sfc-provider</feature>
<feature version="${sxp.version}">odl-sxp-core</feature>
<feature version="${netconf.version}">odl-netconf-topology</feature>
+ <bundle>mvn:org.opendaylight.groupbasedpolicy/l2-l3-domain-extension/{{VERSION}}</bundle>
<bundle>mvn:org.opendaylight.groupbasedpolicy/sxp-mapper/{{VERSION}}</bundle>
<bundle>mvn:org.opendaylight.groupbasedpolicy/ios-xe-renderer/{{VERSION}}</bundle>
+ <configfile finalname="${config.configfile.directory}/15-l2-l3-domain-extension.xml">mvn:org.opendaylight.groupbasedpolicy/l2-l3-domain-extension/{{VERSION}}/xml/config</configfile>
<configfile finalname="${config.configfile.directory}/15-groupbasedpolicy-ios-xe-renderer.xml">mvn:org.opendaylight.groupbasedpolicy/ios-xe-renderer/{{VERSION}}/xml/config</configfile>
</feature>
</features>
endpointAugmentorRegistryImpl = new EndpointAugmentorRegistryImpl();
netDomainAugmentorRegistryImpl = new NetworkDomainAugmentorRegistryImpl();
baseEndpointServiceImpl = new BaseEndpointServiceImpl(dataProvider, rpcRegistry, endpointAugmentorRegistryImpl);
- rendererManager = new RendererManager(dataProvider, netDomainAugmentorRegistryImpl);
+ rendererManager = new RendererManager(dataProvider, netDomainAugmentorRegistryImpl, endpointAugmentorRegistryImpl);
}
@Override
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.endpoints.ContainmentEndpointWithLocation;
import org.opendaylight.yangtools.yang.binding.Augmentation;
+import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.util.Map;
*/
@Nullable
Map.Entry<Class<? extends Augmentation<AddressEndpoint>>, Augmentation<AddressEndpoint>> buildAddressEndpointAugmentation(
- AddressEndpointReg input);
+ @Nonnull AddressEndpointReg input);
/**
* Creates pair of {@link ContainmentEndpoint} augmentation. Augmentation is domain specific.
*/
@Nullable
Map.Entry<Class<? extends Augmentation<ContainmentEndpoint>>, Augmentation<ContainmentEndpoint>> buildContainmentEndpointAugmentation(
- ContainmentEndpointReg input);
+ @Nonnull ContainmentEndpointReg input);
/**
* Creates pair of {@link AddressEndpointWithLocation} augmentation. Augmentation is domain
*/
@Nullable
Map.Entry<Class<? extends Augmentation<AddressEndpointWithLocation>>, Augmentation<AddressEndpointWithLocation>> buildAddressEndpointWithLocationAugmentation(
- AddressEndpoint input);
+ @Nonnull AddressEndpoint input);
/**
* Creates pair of {@link ContainmentEndpointWithLocation} augmentation. Augmentation is domain
*/
@Nullable
Map.Entry<Class<? extends Augmentation<ContainmentEndpointWithLocation>>, Augmentation<ContainmentEndpointWithLocation>> buildContainmentEndpointWithLocationAugmentation(
- ContainmentEndpoint input);
+ @Nonnull ContainmentEndpoint input);
}
import java.util.Map;
+import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.NetworkDomain;
*/
@Nullable
Map.Entry<Class<? extends Augmentation<RendererNetworkDomain>>, Augmentation<RendererNetworkDomain>> buildRendererNetworkDomainAugmentation(
- NetworkDomain input);
+ @Nonnull NetworkDomain input);
}
}
}
- public Set<NetworkDomainAugmentor> getEndpointAugmentors() {
+ public Set<NetworkDomainAugmentor> getNetworkDomainAugmentors() {
return augmentors;
}
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
import org.opendaylight.groupbasedpolicy.util.IidFactory;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.AddressEndpointLocation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.AddressEndpointLocationBuilder;
break;
}
}
- wtx.submit();
+ LOG.debug("Writing endpoint location changes to DS");
+ DataStoreHelper.submitToDs(wtx);
}
}
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
+import org.opendaylight.groupbasedpolicy.api.EndpointAugmentor;
import org.opendaylight.groupbasedpolicy.api.NetworkDomainAugmentor;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.AddressEndpointLocation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoint.locations.ContainmentEndpointLocation;
}
public Endpoints buildEndoints(EndpointInfo epInfo, EndpointLocationInfo epLocInfo,
- Map<InstanceIdentifier<?>, RendererName> rendererByNode) {
+ Map<InstanceIdentifier<?>, RendererName> rendererByNode, Set<EndpointAugmentor> augmentors) {
List<AddressEndpointWithLocation> epsWithLoc =
- resolveEpsWithLoc(getAddressEndpointKeys(), epInfo, epLocInfo, rendererByNode);
+ resolveEpsWithLoc(getAddressEndpointKeys(), epInfo, epLocInfo, rendererByNode, augmentors);
List<ContainmentEndpointWithLocation> contEpsWithLoc =
- resolveContEpsWithLoc(getContainmentEndpointKeys(), epInfo, epLocInfo);
+ resolveContEpsWithLoc(getContainmentEndpointKeys(), epInfo, epLocInfo, augmentors);
return new EndpointsBuilder().setAddressEndpointWithLocation(epsWithLoc)
.setContainmentEndpointWithLocation(contEpsWithLoc)
.build();
private static List<AddressEndpointWithLocation> resolveEpsWithLoc(Set<AddressEndpointKey> epKeys,
EndpointInfo epInfo, EndpointLocationInfo epLocInfo,
- Map<InstanceIdentifier<?>, RendererName> rendererByNode) {
+ Map<InstanceIdentifier<?>, RendererName> rendererByNode, Set<EndpointAugmentor> augmentors) {
List<AddressEndpointWithLocation> result = new ArrayList<>();
for (AddressEndpointKey epKey : epKeys) {
Optional<AddressEndpoint> potentialEp = epInfo.getEndpoint(epKey);
Optional<AddressEndpointLocation> potentionalEpLoc = epLocInfo.getAdressEndpointLocation(epKey);
Preconditions.checkArgument(potentionalEpLoc.isPresent());
RendererName rendererName = resolveRendererName(potentionalEpLoc.get(), rendererByNode);
- result.add(createEpWithLoc(potentialEp.get(), potentionalEpLoc.get(), rendererName));
+ result.add(createEpWithLoc(potentialEp.get(), potentionalEpLoc.get(), rendererName, augmentors));
}
return result;
}
}
private static AddressEndpointWithLocation createEpWithLoc(AddressEndpoint ep, AddressEndpointLocation epLoc,
- RendererName rendererName) {
- return new AddressEndpointWithLocationBuilder().setAddress(ep.getAddress())
+ RendererName rendererName, Set<EndpointAugmentor> augmentors) {
+ AddressEndpointWithLocationBuilder addrEpWithLoc = new AddressEndpointWithLocationBuilder()
+ .setAddress(ep.getAddress())
.setAddressType(ep.getAddressType())
.setContextId(ep.getContextId())
.setContextType(ep.getContextType())
.setTimestamp(ep.getTimestamp())
.setAbsoluteLocation(epLoc.getAbsoluteLocation())
.setRelativeLocations(epLoc.getRelativeLocations())
- .setRendererName(rendererName)
- .build();
+ .setRendererName(rendererName);
+ for (EndpointAugmentor augmentor : augmentors) {
+ Entry<Class<? extends Augmentation<AddressEndpointWithLocation>>, Augmentation<AddressEndpointWithLocation>> addrEpWithLocAug =
+ augmentor.buildAddressEndpointWithLocationAugmentation(ep);
+ if (addrEpWithLocAug != null) {
+ addrEpWithLoc.addAugmentation(addrEpWithLocAug.getKey(), addrEpWithLocAug.getValue());
+ }
+ }
+ return addrEpWithLoc.build();
}
private static List<ContainmentEndpointWithLocation> resolveContEpsWithLoc(Set<ContainmentEndpointKey> contEpKeys,
- EndpointInfo epInfo, EndpointLocationInfo epLocInfo) {
+ EndpointInfo epInfo, EndpointLocationInfo epLocInfo, Set<EndpointAugmentor> augmentors) {
List<ContainmentEndpointWithLocation> result = new ArrayList<>();
for (ContainmentEndpointKey contEpKey : contEpKeys) {
Optional<ContainmentEndpoint> potentialContEp = epInfo.getContainmentEndpoint(contEpKey);
Optional<ContainmentEndpointLocation> potentialContEpLoc =
epLocInfo.getContainmentEndpointLocation(contEpKey);
Preconditions.checkArgument(potentialContEpLoc.isPresent());
- result.add(createContEpWithLoc(potentialContEp.get(), potentialContEpLoc.get()));
+ result.add(createContEpWithLoc(potentialContEp.get(), potentialContEpLoc.get(), augmentors));
}
return result;
}
private static ContainmentEndpointWithLocation createContEpWithLoc(ContainmentEndpoint contEp,
- ContainmentEndpointLocation contEpLoc) {
- return new ContainmentEndpointWithLocationBuilder().setContextId(contEp.getContextId())
+ ContainmentEndpointLocation contEpLoc, Set<EndpointAugmentor> augmentors) {
+ ContainmentEndpointWithLocationBuilder contEpWithLoc = new ContainmentEndpointWithLocationBuilder()
+ .setContextId(contEp.getContextId())
.setContextType(contEp.getContextType())
.setTenant(contEp.getTenant())
.setChildEndpoint(contEp.getChildEndpoint())
.setCondition(contEp.getCondition())
.setNetworkContainment(contEp.getNetworkContainment())
.setTimestamp(contEp.getTimestamp())
- .setRelativeLocations(contEpLoc.getRelativeLocations())
- .build();
+ .setRelativeLocations(contEpLoc.getRelativeLocations());
+ for (EndpointAugmentor augmentor : augmentors) {
+ Entry<Class<? extends Augmentation<ContainmentEndpointWithLocation>>, Augmentation<ContainmentEndpointWithLocation>> contEpWithLocAug =
+ augmentor.buildContainmentEndpointWithLocationAugmentation(contEp);
+ if (contEpWithLocAug != null) {
+ contEpWithLoc.addAugmentation(contEpWithLocAug.getKey(), contEpWithLocAug.getValue());
+ }
+ }
+ return contEpWithLoc.build();
}
public RuleGroups buildRuluGroups(ResolvedPolicyInfo policyInfo) {
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.base_endpoint.EndpointAugmentorRegistryImpl;
import org.opendaylight.groupbasedpolicy.dto.ConsEpgKey;
import org.opendaylight.groupbasedpolicy.dto.EpgKeyDto;
import org.opendaylight.groupbasedpolicy.dto.ProvEpgKey;
private final DataBroker dataProvider;
private final NetworkDomainAugmentorRegistryImpl netDomainAugmentorRegistry;
+ private final EndpointAugmentorRegistryImpl epAugmentorRegistry;
private final Set<RendererName> processingRenderers = new HashSet<>();
private Map<InstanceIdentifier<?>, RendererName> rendererByNode = new HashMap<>();
private ResolvedPolicyInfo policyInfo;
private EndpointInfo epInfo;
private EndpointLocationInfo epLocInfo;
private Forwarding forwarding;
+ private boolean changesWaitingToProcess = false;
+ private boolean currentVersionHasConfig = false;
private final EndpointsListener endpointsListener;
private final EndpointLocationsListener endpointLocationsListener;
private final ForwardingListener forwardingListener;
private final RenderersListener renderersListener;
- public RendererManager(DataBroker dataProvider, NetworkDomainAugmentorRegistryImpl netDomainAugmentorRegistry) {
+ public RendererManager(DataBroker dataProvider, NetworkDomainAugmentorRegistryImpl netDomainAugmentorRegistry,
+ EndpointAugmentorRegistryImpl epAugmentorRegistry) {
this.dataProvider = checkNotNull(dataProvider);
this.netDomainAugmentorRegistry = checkNotNull(netDomainAugmentorRegistry);
+ this.epAugmentorRegistry = checkNotNull(epAugmentorRegistry);
endpointsListener = new EndpointsListener(this, dataProvider);
endpointLocationsListener = new EndpointLocationsListener(this, dataProvider);
resolvedPoliciesListener = new ResolvedPoliciesListener(this, dataProvider);
public synchronized void endpointsUpdated(final Endpoints endpoints) {
epInfo = new EndpointInfo(endpoints);
+ changesWaitingToProcess = true;
processState();
}
public synchronized void endpointLocationsUpdated(final EndpointLocations epLocations) {
epLocInfo = new EndpointLocationInfo(epLocations);
+ changesWaitingToProcess = true;
processState();
}
public synchronized void resolvedPoliciesUpdated(final ResolvedPolicies resolvedPolicies) {
policyInfo = new ResolvedPolicyInfo(resolvedPolicies);
+ changesWaitingToProcess = true;
processState();
}
public synchronized void forwardingUpdated(final Forwarding forwarding) {
this.forwarding = forwarding;
+ changesWaitingToProcess = true;
processState();
}
rendererByNode.put(nodePath, renderers.asList().get(0));
}
if (processingRenderers.isEmpty()) {
- processState();
+ changesWaitingToProcess = true;
} else {
LOG.debug("Waiting for renderers. Version {} needs to be processed by renderers: {}", version,
processingRenderers);
}
}
}
+ processState();
}
private void processState() {
if (rendererByNode.values().isEmpty()) {
return;
}
-
- version++;
+ if (!changesWaitingToProcess) {
+ return;
+ }
Map<RendererName, RendererConfigurationBuilder> rendererConfigBuilderByRendererName = createRendererConfigBuilders();
- List<Renderer> renderers = new ArrayList<>();
Set<RendererName> rendererNames = new HashSet<>(rendererByNode.values());
+ boolean newVersionHasConfig = false;
+ Map<RendererName, Optional<Configuration>> configsByRendererName = new HashMap<>();
for (RendererName rendererName : rendererNames) {
RendererConfigurationBuilder rendererPolicyBuilder = rendererConfigBuilderByRendererName.get(rendererName);
Optional<Configuration> potentialConfig = createConfiguration(rendererPolicyBuilder);
- RendererPolicy rendererPolicy = null;
if (potentialConfig.isPresent()) {
- LOG.debug("Created configuration for renderer with version {}", rendererName.getValue(), version);
- rendererPolicy =
- new RendererPolicyBuilder().setVersion(version).setConfiguration(potentialConfig.get()).build();
+ newVersionHasConfig = true;
+ }
+ configsByRendererName.put(rendererName, potentialConfig);
+ }
+ if (newVersionHasConfig || currentVersionHasConfig) {
+ version++;
+ if (!writeRenderersConfigs(configsByRendererName)) {
+ LOG.warn("Version {} was not dispatched successfully. Previous version is valid until next update.",
+ version);
+ for (RendererName rendererName : rendererConfigBuilderByRendererName.keySet()) {
+ processingRenderers.remove(rendererName);
+ }
+ version--;
+ changesWaitingToProcess = true;
+ return;
+ } else {
+ currentVersionHasConfig = newVersionHasConfig;
+ }
+ }
+ changesWaitingToProcess = false;
+ }
+
+ private boolean writeRenderersConfigs(Map<RendererName, Optional<Configuration>> configsByRendererName) {
+ List<Renderer> renderers = new ArrayList<>();
+ for (RendererName rendererName : configsByRendererName.keySet()) {
+ RendererPolicy rendererPolicy = null;
+ if (configsByRendererName.get(rendererName).isPresent()) {
+ rendererPolicy = new RendererPolicyBuilder().setVersion(version)
+ .setConfiguration(configsByRendererName.get(rendererName).get())
+ .build();
+
} else {
- rendererPolicy =
- new RendererPolicyBuilder().setVersion(version).build();
+ rendererPolicy = new RendererPolicyBuilder().setVersion(version).build();
}
renderers.add(new RendererBuilder().setName(rendererName).setRendererPolicy(rendererPolicy).build());
processingRenderers.add(rendererName);
+ LOG.debug("Created configuration for renderer {} with version {}", rendererName.getValue(), version);
}
WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
wTx.put(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.create(Renderers.class),
new RenderersBuilder().setRenderer(renderers).build());
- if (!DataStoreHelper.submitToDs(wTx)) {
- LOG.warn("Version {} was not dispatched successfully. Previous version is valid till next update.",
- version);
- for (RendererName rendererName : rendererConfigBuilderByRendererName.keySet()) {
- processingRenderers.remove(rendererName);
- }
- version--;
- }
+ return DataStoreHelper.submitToDs(wTx);
}
/**
* Entry is added to the result map only if:<br>
* 1. There is at least one Address EP with absolute location
* 2. There is a renderer responsible for that EP
- *
+ *
* @return
*/
private Map<RendererName, RendererConfigurationBuilder> createRendererConfigBuilders() {
configBuilder.setRendererEndpoints(rendererEndpoints);
org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.policy.configuration.Endpoints endpoints =
- rendererPolicyBuilder.buildEndoints(epInfo, epLocInfo, rendererByNode);
+ rendererPolicyBuilder.buildEndoints(epInfo, epLocInfo, rendererByNode, epAugmentorRegistry.getEndpointAugmentors());
configBuilder.setEndpoints(endpoints);
RuleGroups ruleGroups = rendererPolicyBuilder.buildRuluGroups(policyInfo);
configBuilder.setRuleGroups(ruleGroups);
RendererForwarding rendererForwarding = rendererPolicyBuilder.buildRendererForwarding(forwarding,
- netDomainAugmentorRegistry.getEndpointAugmentors());
+ netDomainAugmentorRegistry.getNetworkDomainAugmentors());
configBuilder.setRendererForwarding(rendererForwarding);
return Optional.of(configBuilder.build());
return;
}
for (AddressEndpointKey peerAdrEpKey : peerAdrEps) {
+ if (isSameKeys(rendererEpKey, peerAdrEpKey)) {
+ continue;
+ }
ExternalImplicitGroup eig = policy.getExternalImplicitGroup();
if (eig != null) {
if (!epLocInfo.hasRelativeLocation(peerAdrEpKey)) {
return false;
}
+ private boolean isSameKeys(RendererEndpointKey rendererEpKey, AddressEndpointKey peerAdrEpKey) {
+ if (rendererEpKey.getAddress().equals(peerAdrEpKey.getAddress())
+ && rendererEpKey.getAddressType().equals(peerAdrEpKey.getAddressType())
+ && rendererEpKey.getContextId().equals(peerAdrEpKey.getContextId())
+ && rendererEpKey.getContextType().equals(peerAdrEpKey.getContextType())) {
+ return true;
+ }
+ return false;
+ }
+
private Set<EpgKeyDto> toEpgKeys(List<EndpointGroupId> epgIds, TenantId tenantId) {
return FluentIterable.from(epgIds).transform(new Function<EndpointGroupId, EpgKeyDto>() {
}
Builder<InstanceIdentifier<?>, RendererName> renderersByNodeBuilder = ImmutableMultimap.builder();
for (Renderer renderer : renderers) {
+ if (renderer.getRendererNodes() == null) {
+ continue;
+ }
List<RendererNode> rendererNodes = renderer.getRendererNodes().getRendererNode();
if (rendererNodes == null) {
continue;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.groupbasedpolicy.util.DataTreeChangeHandler;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.Forwarding;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.ForwardingByTenant;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public ForwardingResolver(DataBroker dataProvider) {
super(dataProvider);
+ registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.builder(Forwarding.class).child(ForwardingByTenant.class).build()));
}
@Override
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2BridgeDomainId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2FloodDomainId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L3ContextId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.NetworkDomainId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.RuleName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SelectorName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubjectName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.LocationProviderKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.location.provider.ProviderAddressEndpointLocation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.location.provider.ProviderAddressEndpointLocationKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L2BridgeDomain;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L2FloodDomain;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.Subnet;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.AddressType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.ContextType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.Forwarding;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.ForwardingByTenant;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.ForwardingByTenantKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.ForwardingContext;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.ForwardingContextKey;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.NetworkDomain;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.NetworkDomainKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.SubjectFeatureDefinitions;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.Tenants;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.has.classifier.refs.ClassifierRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.statistics.store.rev151215.statistics.store.StatisticRecord;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.statistics.store.rev151215.statistics.store.StatisticRecordKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
-import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
public class IidFactory {
.build();
}
- public static InstanceIdentifier<NetworkDomain> subnetIid(TenantId tenantId, NetworkDomainId id) {
- NetworkDomainKey domainKey = new NetworkDomainKey(id, Subnet.class);
- return createForwardingByTenantIidBuilder(tenantId).child(NetworkDomain.class, domainKey).build();
- }
-
- public static InstanceIdentifier<ForwardingContext> l2FloodDomainIid(TenantId tenantId, ContextId id) {
- ForwardingContextKey domainKey = new ForwardingContextKey(id, L2FloodDomain.class);
- return createForwardingByTenantIidBuilder(tenantId).child(ForwardingContext.class, domainKey).build();
- }
-
- public static InstanceIdentifier<ForwardingContext> l2BridgeDomainIid(TenantId tenantId, ContextId id) {
- ForwardingContextKey domainKey = new ForwardingContextKey(id, L2BridgeDomain.class);
- return createForwardingByTenantIidBuilder(tenantId).child(ForwardingContext.class, domainKey).build();
- }
-
- public static InstanceIdentifier<ForwardingContext> l3ContextIid(TenantId tenantId, ContextId id) {
- ForwardingContextKey domainKey = new ForwardingContextKey(id, L3Context.class);
- return createForwardingByTenantIidBuilder(tenantId).child(ForwardingContext.class, domainKey).build();
- }
-
- private static InstanceIdentifierBuilder<ForwardingByTenant> createForwardingByTenantIidBuilder(TenantId tenantId) {
- return InstanceIdentifier.builder(Forwarding.class).child(ForwardingByTenant.class,
- new ForwardingByTenantKey(tenantId));
- }
-
@Deprecated
public static InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L2FloodDomain> l2FloodDomainIid(TenantId tenantId,
L2FloodDomainId l2FloodDomainId) {
.build();
}
- public static InstanceIdentifier<ProviderAddressEndpointLocation> providerAddressEndpointLocationIid(String provider,
- Class<? extends AddressType> addrType, String addr, Class<? extends ContextType> cType,
+ public static InstanceIdentifier<ProviderAddressEndpointLocation> providerAddressEndpointLocationIid(
+ String provider, Class<? extends AddressType> addrType, String addr, Class<? extends ContextType> cType,
ContextId containment) {
+ return providerAddressEndpointLocationIid(new ProviderName(provider),
+ new ProviderAddressEndpointLocationKey(addr, addrType, containment, cType));
+ }
+
+ public static InstanceIdentifier<ProviderAddressEndpointLocation> providerAddressEndpointLocationIid(
+ ProviderName provider, ProviderAddressEndpointLocationKey providerAddressEndpointLocationKey) {
+ return locationProviderIid(provider).child(ProviderAddressEndpointLocation.class,
+ providerAddressEndpointLocationKey);
+ }
+
+ public static InstanceIdentifier<LocationProvider> locationProviderIid(ProviderName provider) {
return InstanceIdentifier.builder(LocationProviders.class)
- .child(LocationProvider.class, new LocationProviderKey(new ProviderName(provider)))
- .child(ProviderAddressEndpointLocation.class, new ProviderAddressEndpointLocationKey(addr, addrType, containment, cType))
+ .child(LocationProvider.class, new LocationProviderKey(provider))
.build();
}
if (prefix1.getIpv4Prefix() != null && prefix2.getIpv4Prefix() != null) {
SubnetUtils fromPrefix1 = new SubnetUtils(prefix1.getIpv4Prefix().getValue());
SubnetUtils fromPrefix2 = new SubnetUtils(prefix2.getIpv4Prefix().getValue());
- if (fromPrefix1.getInfo().isInRange(fromPrefix2.getInfo().getHighAddress())
- && fromPrefix2.getInfo().isInRange(fromPrefix1.getInfo().getHighAddress())) {
+ if (fromPrefix1.getInfo().getNetworkAddress().equals(fromPrefix2.getInfo().getNetworkAddress())
+ && fromPrefix1.getInfo().getNetmask().equals(fromPrefix2.getInfo().getNetmask())) {
return true;
}
} else if (prefix1.getIpv6Prefix() != null && prefix2.getIpv6Prefix() != null) {
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContextId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.NetworkDomainId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.IpPrefixType;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L2FloodDomain;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.MacAddressType;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.Subnet;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.AddressType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.ContextType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.NetworkDomain;
import org.opendaylight.yangtools.yang.common.RpcResult;
import com.google.common.base.Optional;
private static final String CONTEXT_ID = "testContext";
private static final long timestamp = 1234567890L;
private static final NetworkDomainContainment networkDomainContainment = new NetworkDomainContainmentBuilder()
- .setNetworkDomainId(new NetworkDomainId(DOMAIN)).setNetworkDomainType(Subnet.class).build();
+ .setNetworkDomainId(new NetworkDomainId(DOMAIN)).setNetworkDomainType(NetworkDomain.class).build();
private static final ParentEndpoint BASE_L3_PARENT = new ParentEndpointBuilder().setAddress(IP_ADDRESS)
- .setAddressType(IpPrefixType.class)
+ .setAddressType(AddressType.class)
.setContextId(new ContextId(CONTEXT_ID))
- .setContextType(L3Context.class)
+ .setContextType(ContextType.class)
.build();
private static final ChildEndpoint BASE_L2_CHILD = new ChildEndpointBuilder().setAddress(MAC_ADDRESS)
- .setAddressType(MacAddressType.class)
+ .setAddressType(AddressType.class)
.setContextId(new ContextId(CONTEXT_ID))
- .setContextType(L2FloodDomain.class)
+ .setContextType(ContextType.class)
.build();
private static final ParentContainmentEndpoint BASE_CONT_PARENT = new ParentContainmentEndpointBuilder()
- .setContextId(new ContextId(CONTEXT_ID)).setContextType(L2FloodDomain.class).build();
+ .setContextId(new ContextId(CONTEXT_ID)).setContextType(ContextType.class).build();
private DataBroker dataProvider;
private BaseEndpointServiceImpl baseEndpointRpcRegistry;
@Override
public Collection<Class<?>> getClassesFromModules() {
- return ImmutableList.of(Endpoints.class, AddressEndpoints.class, ContainmentEndpoints.class,
- MacAddressType.class, IpPrefixType.class);
+ return ImmutableList.of(Endpoints.class, AddressEndpoints.class, ContainmentEndpoints.class);
}
@Before
private AddressEndpointBuilder createBaseL2EpBuilder() {
return new AddressEndpointBuilder().setTimestamp(timestamp)
.setContextId(new ContextId(CONTEXT_ID))
- .setContextType(L2FloodDomain.class)
+ .setContextType(ContextType.class)
.setTenant(new TenantId(TENANT))
.setAddress(MAC_ADDRESS)
- .setAddressType(MacAddressType.class)
+ .setAddressType(AddressType.class)
.setNetworkContainment(new NetworkContainmentBuilder().setContainment(networkDomainContainment).build())
.setTimestamp(timestamp);
}
private AddressEndpointBuilder createBaseL3EpBuilder() {
return new AddressEndpointBuilder().setTimestamp(timestamp)
.setContextId(new ContextId(CONTEXT_ID))
- .setContextType(L3Context.class)
+ .setContextType(ContextType.class)
.setTenant(new TenantId(TENANT))
.setAddress(IP_ADDRESS)
- .setAddressType(IpPrefixType.class)
+ .setAddressType(AddressType.class)
.setNetworkContainment(new NetworkContainmentBuilder().setContainment(networkDomainContainment).build())
.setTimestamp(timestamp);
}
private ContainmentEndpointBuilder createBaseContEpBuilder() {
return new ContainmentEndpointBuilder().setTimestamp(timestamp)
.setContextId(new ContextId(CONTEXT_ID))
- .setContextType(L2FloodDomain.class)
+ .setContextType(ContextType.class)
.setTenant(new TenantId(TENANT))
.setNetworkContainment(new NetworkContainmentBuilder().setContainment(networkDomainContainment).build());
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.location.provider.ProviderAddressEndpointLocationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.location.provider.ProviderAddressEndpointLocationKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.location.provider.ProviderContainmentEndpointLocationBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.IpPrefixType;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.AddressType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.ContextType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
@Override
public Collection<Class<?>> getClassesFromModules() {
- return ImmutableList.<Class<?>>of(LocationProvider.class, Nodes.class, L3Context.class,
- EndpointLocations.class);
+ return ImmutableList.<Class<?>>of(LocationProvider.class, Nodes.class, EndpointLocations.class);
}
@Test
- public void test_LocationProviderWrite() throws Exception {
+ public void testOnDataTreeChanged_write() throws Exception {
AbsoluteLocation absoluteLocation =
new AbsoluteLocationBuilder().setLocationType(new InternalLocationCaseBuilder()
.setInternalNode(nodeIid1).setInternalNodeConnector(connectorIid).build()).build();
LocationProvider provider = new LocationProviderBuilder().setProvider(new ProviderName(PROVIDER_NAME))
.setProviderAddressEndpointLocation(
Collections.singletonList(new ProviderAddressEndpointLocationBuilder()
- .setKey(new ProviderAddressEndpointLocationKey(ADDRESS, IpPrefixType.class, contextId,
- L3Context.class))
+ .setKey(new ProviderAddressEndpointLocationKey(ADDRESS, AddressType.class, contextId,
+ ContextType.class))
.setAbsoluteLocation(absoluteLocation)
.setRelativeLocations(relativeLocations)
.build()))
.setProviderContainmentEndpointLocation(
Collections.singletonList(new ProviderContainmentEndpointLocationBuilder().setContextId(contextId)
- .setContextType(L3Context.class)
+ .setContextType(ContextType.class)
.setRelativeLocations(relativeLocations)
.build()))
.build();
EndpointLocations readLocations = read.get();
assertNotNull(readLocations.getAddressEndpointLocation());
assertEquals(1, readLocations.getAddressEndpointLocation().size());
- assertEquals(new AddressEndpointLocationKey(ADDRESS, IpPrefixType.class, contextId, L3Context.class),
+ assertEquals(new AddressEndpointLocationKey(ADDRESS, AddressType.class, contextId, ContextType.class),
readLocations.getAddressEndpointLocation().get(0).getKey());
assertEquals(absoluteLocation, readLocations.getAddressEndpointLocation().get(0).getAbsoluteLocation());
assertNotNull(readLocations.getContainmentEndpointLocation());
assertEquals(1, readLocations.getContainmentEndpointLocation().size());
- assertEquals(new ContainmentEndpointLocationKey(contextId, L3Context.class),
+ assertEquals(new ContainmentEndpointLocationKey(contextId, ContextType.class),
readLocations.getContainmentEndpointLocation().get(0).getKey());
assertEquals(relativeLocations, readLocations.getContainmentEndpointLocation().get(0).getRelativeLocations());
}
@Test
- public void test_LocationProviderOverWrite() throws Exception {
- test_LocationProviderWrite();
+ public void testOnDataTreeChanged_overWrite() throws Exception {
+ testOnDataTreeChanged_write();
AbsoluteLocation absoluteLocation =
new AbsoluteLocationBuilder().setLocationType(new InternalLocationCaseBuilder()
.setInternalNode(nodeIid2).setInternalNodeConnector(connectorIid).build()).build();
LocationProvider provider = new LocationProviderBuilder().setProvider(new ProviderName(PROVIDER_NAME))
.setProviderAddressEndpointLocation(
Collections.singletonList(new ProviderAddressEndpointLocationBuilder()
- .setKey(new ProviderAddressEndpointLocationKey(ADDRESS, IpPrefixType.class, contextId,
- L3Context.class))
+ .setKey(new ProviderAddressEndpointLocationKey(ADDRESS, AddressType.class, contextId,
+ ContextType.class))
.setAbsoluteLocation(absoluteLocation)
.setRelativeLocations(relativeLocations)
.build()))
.setProviderContainmentEndpointLocation(
Collections.singletonList(new ProviderContainmentEndpointLocationBuilder().setContextId(contextId)
- .setContextType(L3Context.class)
+ .setContextType(ContextType.class)
.setRelativeLocations(relativeLocations)
.build()))
.build();
EndpointLocations readLocations = read.get();
assertNotNull(readLocations.getAddressEndpointLocation());
assertEquals(1, readLocations.getAddressEndpointLocation().size());
- assertEquals(new AddressEndpointLocationKey(ADDRESS, IpPrefixType.class, contextId, L3Context.class),
+ assertEquals(new AddressEndpointLocationKey(ADDRESS, AddressType.class, contextId, ContextType.class),
readLocations.getAddressEndpointLocation().get(0).getKey());
assertEquals(absoluteLocation, readLocations.getAddressEndpointLocation().get(0).getAbsoluteLocation());
assertNotNull(readLocations.getContainmentEndpointLocation());
assertEquals(1, readLocations.getContainmentEndpointLocation().size());
- assertEquals(new ContainmentEndpointLocationKey(contextId, L3Context.class),
+ assertEquals(new ContainmentEndpointLocationKey(contextId, ContextType.class),
readLocations.getContainmentEndpointLocation().get(0).getKey());
assertEquals(relativeLocations, readLocations.getContainmentEndpointLocation().get(0).getRelativeLocations());
}
@Test
- public void test_LocationProviderDelete() throws Exception {
- test_LocationProviderWrite();
+ public void testOnDataTreeChanged_delete() throws Exception {
+ testOnDataTreeChanged_write();
InstanceIdentifier<LocationProvider> iid = InstanceIdentifier.builder(LocationProviders.class)
.child(LocationProvider.class, new LocationProviderKey(new ProviderName(PROVIDER_NAME)))
.build();
}
@Test
- public void test_LocationProviderModify() throws Exception {
- test_LocationProviderWrite();
+ public void testOnDataTreeChanged_modify() throws Exception {
+ testOnDataTreeChanged_write();
AbsoluteLocation absoluteLocation =
new AbsoluteLocationBuilder().setLocationType(new InternalLocationCaseBuilder()
.setInternalNode(nodeIid2).setInternalNodeConnector(connectorIid).build()).build();
InstanceIdentifier<AbsoluteLocation> iid = InstanceIdentifier.builder(LocationProviders.class)
.child(LocationProvider.class, new LocationProviderKey(new ProviderName(PROVIDER_NAME)))
.child(ProviderAddressEndpointLocation.class,
- new ProviderAddressEndpointLocationKey(ADDRESS, IpPrefixType.class, contextId, L3Context.class))
+ new ProviderAddressEndpointLocationKey(ADDRESS, AddressType.class, contextId, ContextType.class))
.child(AbsoluteLocation.class)
.build();
WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
EndpointLocations readLocations = read.get();
assertNotNull(readLocations.getAddressEndpointLocation());
assertEquals(1, readLocations.getAddressEndpointLocation().size());
- assertEquals(new AddressEndpointLocationKey(ADDRESS, IpPrefixType.class, contextId, L3Context.class),
+ assertEquals(new AddressEndpointLocationKey(ADDRESS, AddressType.class, contextId, ContextType.class),
readLocations.getAddressEndpointLocation().get(0).getKey());
assertEquals(absoluteLocation, readLocations.getAddressEndpointLocation().get(0).getAbsoluteLocation());
}
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.groupbasedpolicy.base_endpoint.EndpointAugmentorRegistryImpl;
import org.opendaylight.groupbasedpolicy.forwarding.NetworkDomainAugmentorRegistryImpl;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.EndpointLocations;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.EndpointLocationsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.RuleName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubjectName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.ContextType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.ForwardingBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.ForwardingByTenantBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.ForwardingContextBuilder;
@Mock
private NetworkDomainAugmentorRegistryImpl netDomainAugmentorRegistry;
@Mock
+ private EndpointAugmentorRegistryImpl epAugmentorRegistry;
+ @Mock
private WriteTransaction wTx;
@Mock
private CheckedFuture<Void, TransactionCommitFailedException> submitFuture;
public void init() {
Mockito.when(dataProvider.newWriteOnlyTransaction()).thenReturn(wTx);
Mockito.when(wTx.submit()).thenReturn(submitFuture);
- Mockito.when(netDomainAugmentorRegistry.getEndpointAugmentors()).thenReturn(Collections.emptySet());
- rendererManager = new RendererManager(dataProvider, netDomainAugmentorRegistry);
+ Mockito.when(netDomainAugmentorRegistry.getNetworkDomainAugmentors()).thenReturn(Collections.emptySet());
+ Mockito.when(epAugmentorRegistry.getEndpointAugmentors()).thenReturn(Collections.emptySet());
+ rendererManager = new RendererManager(dataProvider, netDomainAugmentorRegistry, epAugmentorRegistry);
RendererManager.resetVersion();
}
.setForwardingByTenant(
Arrays.asList(new ForwardingByTenantBuilder().setTenantId(TestDataFactory.TENANT_ID)
.setForwardingContext(Arrays.asList(new ForwardingContextBuilder()
- .setContextType(TestDataFactory.DummyContextType.class)
+ .setContextType(ContextType.class)
.setContextId(TestDataFactory.CTX_1)
.build()))
.build()))
.setForwardingByTenant(
Arrays.asList(new ForwardingByTenantBuilder().setTenantId(TestDataFactory.TENANT_ID)
.setForwardingContext(Arrays.asList(new ForwardingContextBuilder()
- .setContextType(TestDataFactory.DummyContextType.class)
+ .setContextType(ContextType.class)
.setContextId(TestDataFactory.CTX_1)
.build()))
.build()))
.setForwardingByTenant(
Arrays.asList(new ForwardingByTenantBuilder().setTenantId(TestDataFactory.TENANT_ID)
.setForwardingContext(Arrays.asList(new ForwardingContextBuilder()
- .setContextType(TestDataFactory.DummyContextType.class)
+ .setContextType(ContextType.class)
.setContextId(TestDataFactory.CTX_1)
.build()))
.build()))
import org.mockito.Mockito;
import org.mockito.runners.MockitoJUnitRunner;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.groupbasedpolicy.base_endpoint.EndpointAugmentorRegistryImpl;
import org.opendaylight.groupbasedpolicy.forwarding.NetworkDomainAugmentorRegistryImpl;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.EndpointLocations;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.EndpointLocationsBuilder;
private DataBroker dataProvider;
@Mock
private NetworkDomainAugmentorRegistryImpl netDomainAugmentorRegistry;
+ @Mock
+ private EndpointAugmentorRegistryImpl epAugmentorRegistry;
private RendererManager rendererManager;
@Before
public void init() {
- Mockito.when(netDomainAugmentorRegistry.getEndpointAugmentors()).thenReturn(Collections.emptySet());
- rendererManager = new RendererManager(dataProvider, netDomainAugmentorRegistry);
+ Mockito.when(netDomainAugmentorRegistry.getNetworkDomainAugmentors()).thenReturn(Collections.emptySet());
+ Mockito.when(epAugmentorRegistry.getEndpointAugmentors()).thenReturn(Collections.emptySet());
+ rendererManager = new RendererManager(dataProvider, netDomainAugmentorRegistry, epAugmentorRegistry);
}
/**
}
public static AddressEndpointBuilder defaultAdrEp(String address, EndpointGroupId... epgs) {
- return new AddressEndpointBuilder().setContextType(DummyContextType.class)
+ return new AddressEndpointBuilder().setContextType(ContextType.class)
.setContextId(CTX_1)
- .setAddressType(DummyAddressType.class)
+ .setAddressType(AddressType.class)
.setAddress(address)
.setTenant(TENANT_ID)
.setEndpointGroup(Arrays.asList(epgs))
.setNetworkContainment(
new NetworkContainmentBuilder().setContainment(new ForwardingContextContainmentBuilder()
- .setContextType(DummyContextType.class).setContextId(CTX_1).build()).build());
+ .setContextType(ContextType.class).setContextId(CTX_1).build()).build());
}
public static ContainmentEndpointBuilder defaultContEp(EndpointGroupId... epgs) {
- return new ContainmentEndpointBuilder().setContextType(DummyContextType.class)
+ return new ContainmentEndpointBuilder().setContextType(ContextType.class)
.setContextId(CTX_1)
.setTenant(TENANT_ID)
.setEndpointGroup(Arrays.asList(epgs))
.setNetworkContainment(
new NetworkContainmentBuilder().setContainment(new ForwardingContextContainmentBuilder()
- .setContextType(DummyContextType.class).setContextId(CTX_1).build()).build());
+ .setContextType(ContextType.class).setContextId(CTX_1).build()).build());
}
public static ResolvedRuleBuilder defaultResolvedRule(RuleName ruleName) {
.setPolicyRuleGroupWithEndpointConstraints(ImmutableList.of(blueRuleGrpWithoutCons));
}
- public static abstract class DummyContextType extends ContextType {
- };
- public static abstract class DummyAddressType extends AddressType {
- };
}
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
-import org.mockito.Mockito;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
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.groupbasedpolicy.common.rev140421.L2BridgeDomainId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2FloodDomainId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L3ContextId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.NetworkDomainId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.RuleName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SelectorName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubjectName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubnetId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.UniqueId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.Endpoints;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.Endpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointKey;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Prefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.LocationProvider;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.location.provider.ProviderAddressEndpointLocation;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.IpPrefixType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.AddressType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.ContextType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.ForwardingByTenant;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.ForwardingContext;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.forwarding.forwarding.by.tenant.NetworkDomain;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.has.classifier.refs.ClassifierRef;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ActionDefinition;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ClassifierDefinition;
private final String LOCATION_PROVIDER_NAME = "location-provider";
private final String IP_ADDRESS = "192.68.50.71";
- private final String IP_PREFIX = "192.168.50.0/24";
private final String L3_CONTEXT_ID = "l3Context";
private final String CONNECTOR = "connector";
Assert.assertEquals(tenantId, identifier.firstKeyOf(Tenant.class).getId());
}
- @Test
- public void testL2FloodDomainIid() {
- ContextId id = mock(ContextId.class);
- InstanceIdentifier<ForwardingContext> identifier = IidFactory.l2FloodDomainIid(tenantId, id);
- Assert.assertEquals(id, InstanceIdentifier.keyOf(identifier).getContextId());
- Assert.assertEquals(tenantId, identifier.firstKeyOf(ForwardingByTenant.class).getTenantId());
- }
-
@Test
public void testL2FloodDomainIid_tenantApi() {
L2FloodDomainId l2FloodDomainId = mock(L2FloodDomainId.class);
Assert.assertEquals(tenantId, identifier.firstKeyOf(Tenant.class).getId());
}
- @Test
- public void testL2BridgeDomainIid() {
- ContextId id = mock(ContextId.class);
- InstanceIdentifier<ForwardingContext> identifier = IidFactory.l2BridgeDomainIid(tenantId, id);
- Assert.assertEquals(id, InstanceIdentifier.keyOf(identifier).getContextId());
- Assert.assertEquals(tenantId, identifier.firstKeyOf(ForwardingByTenant.class).getTenantId());
- }
-
@Test
public void testL2BridgeDomainIid_tenantApi() {
L2BridgeDomainId l2BridgeDomainId = mock(L2BridgeDomainId.class);
Assert.assertEquals(tenantId, identifier.firstKeyOf(Tenant.class).getId());
}
- @Test
- public void testL3ContextIid() {
- ContextId id = mock(ContextId.class);
- InstanceIdentifier<ForwardingContext> identifier = IidFactory.l3ContextIid(tenantId, id);
- Assert.assertEquals(id, InstanceIdentifier.keyOf(identifier).getContextId());
- Assert.assertEquals(tenantId, identifier.firstKeyOf(ForwardingByTenant.class).getTenantId());
- }
-
@Test
public void testL3ContextIid_tenantApi() {
L3ContextId l3ContextId = mock(L3ContextId.class);
Assert.assertEquals(tenantId, identifier.firstKeyOf(Tenant.class).getId());
}
+ @Test
+ public void testForwardingByTenantIid() {
+ InstanceIdentifier<ForwardingByTenant> forwardingByTenantIid = IidFactory.forwardingByTenantIid(tenantId);
+ Assert.assertEquals(tenantId, forwardingByTenantIid.firstKeyOf(ForwardingByTenant.class).getTenantId());
+ }
+
@Test
public void testEndpointIid() {
L2BridgeDomainId l2Context = mock(L2BridgeDomainId.class);
Assert.assertNotNull(identifier);
}
- @Test
- public void testSubnetIid() {
- NetworkDomainId id = mock(NetworkDomainId.class);
- InstanceIdentifier<NetworkDomain> identifier = IidFactory.subnetIid(tenantId, id);
- Assert.assertEquals(tenantId, identifier.firstKeyOf(ForwardingByTenant.class).getTenantId());
- Assert.assertEquals(id, identifier.firstKeyOf(NetworkDomain.class).getNetworkDomainId());
- }
-
@Test
public void testSubnetIid_tenantApi() {
SubnetId subnetId = mock(SubnetId.class);
}
@Test
- public void testeExternalImplicitGroupIid(){
- InstanceIdentifier<ExternalImplicitGroup>
- identifier = IidFactory.externalImplicitGroupIid(tenantId, epgId);
+ public void testeExternalImplicitGroupIid() {
+ InstanceIdentifier<ExternalImplicitGroup> identifier = IidFactory.externalImplicitGroupIid(tenantId, epgId);
Assert.assertEquals(epgId, identifier.firstKeyOf(ExternalImplicitGroup.class).getId());
}
@Test
public void testProviderAddressEndpointLocationIid() {
ContextId l3Context = new ContextId(L3_CONTEXT_ID);
- InstanceIdentifier<ProviderAddressEndpointLocation> identifier = IidFactory
- .providerAddressEndpointLocationIid(LOCATION_PROVIDER_NAME, IpPrefixType.class, IP_ADDRESS,
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class,
- l3Context);
+ InstanceIdentifier<ProviderAddressEndpointLocation> identifier = IidFactory.providerAddressEndpointLocationIid(
+ LOCATION_PROVIDER_NAME, AddressType.class, IP_ADDRESS, ContextType.class, l3Context);
Assert.assertEquals(LOCATION_PROVIDER_NAME,
identifier.firstKeyOf(LocationProvider.class).getProvider().getValue());
Assert.assertEquals(IP_ADDRESS, identifier.firstKeyOf(ProviderAddressEndpointLocation.class).getAddress());
@Test
public void testAddressEndpointIid() {
ContextId l3Context = new ContextId(L3_CONTEXT_ID);
- InstanceIdentifier<AddressEndpoint> identifier =
- IidFactory.addressEndpointIid(new AddressEndpointKey(IP_ADDRESS, IpPrefixType.class, l3Context,
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class
- ));
- Assert.assertEquals(IpPrefixType.class, identifier.firstKeyOf(AddressEndpoint.class).getAddressType());
+ InstanceIdentifier<AddressEndpoint> identifier = IidFactory.addressEndpointIid(
+ new AddressEndpointKey(IP_ADDRESS, AddressType.class, l3Context, ContextType.class));
+ Assert.assertEquals(AddressType.class, identifier.firstKeyOf(AddressEndpoint.class).getAddressType());
Assert.assertEquals(IP_ADDRESS, identifier.firstKeyOf(AddressEndpoint.class).getAddress());
- Assert.assertEquals(
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class,
- identifier.firstKeyOf(AddressEndpoint.class).getContextType());
+ Assert.assertEquals(ContextType.class, identifier.firstKeyOf(AddressEndpoint.class).getContextType());
Assert.assertEquals(l3Context, identifier.firstKeyOf(AddressEndpoint.class).getContextId());
}
public void testAddressEndpointLocationIid() {
ContextId l3Context = new ContextId(L3_CONTEXT_ID);
AddressEndpointLocationKey addrEndpointLocationKey =
- new AddressEndpointLocationKey(IP_ADDRESS, IpPrefixType.class, l3Context,
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class);
- InstanceIdentifier<AddressEndpointLocation> iid = IidFactory.addressEndpointLocationIid(addrEndpointLocationKey);
- Assert.assertEquals(IpPrefixType.class, iid.firstKeyOf(AddressEndpointLocation.class).getAddressType());
+ new AddressEndpointLocationKey(IP_ADDRESS, AddressType.class, l3Context, ContextType.class);
+ InstanceIdentifier<AddressEndpointLocation> iid =
+ IidFactory.addressEndpointLocationIid(addrEndpointLocationKey);
+ Assert.assertEquals(AddressType.class, iid.firstKeyOf(AddressEndpointLocation.class).getAddressType());
Assert.assertEquals(IP_ADDRESS, iid.firstKeyOf(AddressEndpointLocation.class).getAddress());
- Assert.assertEquals(
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class,
- iid.firstKeyOf(AddressEndpointLocation.class).getContextType());
+ Assert.assertEquals(ContextType.class, iid.firstKeyOf(AddressEndpointLocation.class).getContextType());
Assert.assertEquals(l3Context, iid.firstKeyOf(AddressEndpointLocation.class).getContextId());
}
public void testContainmentEndpointLocationIid() {
ContextId l3Context = new ContextId(L3_CONTEXT_ID);
ContainmentEndpointLocationKey contEndpointLocationKey =
- new ContainmentEndpointLocationKey(l3Context,
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class);
- InstanceIdentifier<ContainmentEndpointLocation> iid = IidFactory.containmentEndpointLocationIid(contEndpointLocationKey);
- Assert.assertEquals(
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class,
- iid.firstKeyOf(ContainmentEndpointLocation.class).getContextType());
+ new ContainmentEndpointLocationKey(l3Context, ContextType.class);
+ InstanceIdentifier<ContainmentEndpointLocation> iid =
+ IidFactory.containmentEndpointLocationIid(contEndpointLocationKey);
+ Assert.assertEquals(ContextType.class, iid.firstKeyOf(ContainmentEndpointLocation.class).getContextType());
Assert.assertEquals(l3Context, iid.firstKeyOf(ContainmentEndpointLocation.class).getContextId());
}
public void internalLocationIid_AddrEndpoint() {
ContextId l3Context = new ContextId(L3_CONTEXT_ID);
AddressEndpointLocationKey addrEndpointLocationKey =
- new AddressEndpointLocationKey(IP_ADDRESS, IpPrefixType.class, l3Context,
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class);
+ new AddressEndpointLocationKey(IP_ADDRESS, AddressType.class, l3Context, ContextType.class);
InternalLocationKey internalLocationKey = new InternalLocationKey(nodeIid, connectorIid);
- InstanceIdentifier<InternalLocation> iid = IidFactory.internalLocationIid(addrEndpointLocationKey, internalLocationKey);
- Assert.assertEquals(IpPrefixType.class, iid.firstKeyOf(AddressEndpointLocation.class).getAddressType());
+ InstanceIdentifier<InternalLocation> iid =
+ IidFactory.internalLocationIid(addrEndpointLocationKey, internalLocationKey);
+ Assert.assertEquals(AddressType.class, iid.firstKeyOf(AddressEndpointLocation.class).getAddressType());
Assert.assertEquals(IP_ADDRESS, iid.firstKeyOf(AddressEndpointLocation.class).getAddress());
- Assert.assertEquals(
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class,
- iid.firstKeyOf(AddressEndpointLocation.class).getContextType());
+ Assert.assertEquals(ContextType.class, iid.firstKeyOf(AddressEndpointLocation.class).getContextType());
Assert.assertEquals(l3Context, iid.firstKeyOf(AddressEndpointLocation.class).getContextId());
Assert.assertEquals(nodeIid, iid.firstKeyOf(InternalLocation.class).getInternalNode());
Assert.assertEquals(connectorIid, iid.firstKeyOf(InternalLocation.class).getInternalNodeConnector());
public void internalLocationIid_ContEndpoint() {
ContextId l3Context = new ContextId(L3_CONTEXT_ID);
ContainmentEndpointLocationKey contEndpointLocationKey =
- new ContainmentEndpointLocationKey(l3Context,
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class);
+ new ContainmentEndpointLocationKey(l3Context, ContextType.class);
InternalLocationKey internalLocationKey = new InternalLocationKey(nodeIid, connectorIid);
- InstanceIdentifier<InternalLocation> iid = IidFactory.internalLocationIid(contEndpointLocationKey, internalLocationKey);
- Assert.assertEquals(
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class,
- iid.firstKeyOf(ContainmentEndpointLocation.class).getContextType());
+ InstanceIdentifier<InternalLocation> iid =
+ IidFactory.internalLocationIid(contEndpointLocationKey, internalLocationKey);
+ Assert.assertEquals(ContextType.class, iid.firstKeyOf(ContainmentEndpointLocation.class).getContextType());
Assert.assertEquals(l3Context, iid.firstKeyOf(ContainmentEndpointLocation.class).getContextId());
Assert.assertEquals(nodeIid, iid.firstKeyOf(InternalLocation.class).getInternalNode());
Assert.assertEquals(connectorIid, iid.firstKeyOf(InternalLocation.class).getInternalNodeConnector());
public void externalLocationIid_AddrEndpoint() {
ContextId l3Context = new ContextId(L3_CONTEXT_ID);
AddressEndpointLocationKey addrEndpointLocationKey =
- new AddressEndpointLocationKey(IP_ADDRESS, IpPrefixType.class, l3Context,
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class);
+ new AddressEndpointLocationKey(IP_ADDRESS, AddressType.class, l3Context, ContextType.class);
ExternalLocationKey externalLocationKey = new ExternalLocationKey(CONNECTOR, nodeIid);
- InstanceIdentifier<ExternalLocation> iid = IidFactory.externalLocationIid(addrEndpointLocationKey, externalLocationKey);
- Assert.assertEquals(IpPrefixType.class, iid.firstKeyOf(AddressEndpointLocation.class).getAddressType());
+ InstanceIdentifier<ExternalLocation> iid =
+ IidFactory.externalLocationIid(addrEndpointLocationKey, externalLocationKey);
+ Assert.assertEquals(AddressType.class, iid.firstKeyOf(AddressEndpointLocation.class).getAddressType());
Assert.assertEquals(IP_ADDRESS, iid.firstKeyOf(AddressEndpointLocation.class).getAddress());
- Assert.assertEquals(
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class,
- iid.firstKeyOf(AddressEndpointLocation.class).getContextType());
+ Assert.assertEquals(ContextType.class, iid.firstKeyOf(AddressEndpointLocation.class).getContextType());
Assert.assertEquals(l3Context, iid.firstKeyOf(AddressEndpointLocation.class).getContextId());
Assert.assertEquals(CONNECTOR, iid.firstKeyOf(ExternalLocation.class).getExternalNodeConnector());
Assert.assertEquals(nodeIid, iid.firstKeyOf(ExternalLocation.class).getExternalNodeMountPoint());
public void externalLocationIid_ContEndpoint() {
ContextId l3Context = new ContextId(L3_CONTEXT_ID);
ContainmentEndpointLocationKey addrEndpointLocationKey =
- new ContainmentEndpointLocationKey(l3Context,
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class);
+ new ContainmentEndpointLocationKey(l3Context, ContextType.class);
ExternalLocationKey externalLocationKey = new ExternalLocationKey(CONNECTOR, nodeIid);
- InstanceIdentifier<ExternalLocation> iid = IidFactory.externalLocationIid(addrEndpointLocationKey, externalLocationKey);
- Assert.assertEquals(
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class,
- iid.firstKeyOf(ContainmentEndpointLocation.class).getContextType());
+ InstanceIdentifier<ExternalLocation> iid =
+ IidFactory.externalLocationIid(addrEndpointLocationKey, externalLocationKey);
+ Assert.assertEquals(ContextType.class, iid.firstKeyOf(ContainmentEndpointLocation.class).getContextType());
Assert.assertEquals(l3Context, iid.firstKeyOf(ContainmentEndpointLocation.class).getContextId());
Assert.assertEquals(CONNECTOR, iid.firstKeyOf(ExternalLocation.class).getExternalNodeConnector());
Assert.assertEquals(nodeIid, iid.firstKeyOf(ExternalLocation.class).getExternalNodeMountPoint());
public void absoluteLocationIid() {
ContextId l3Context = new ContextId(L3_CONTEXT_ID);
AddressEndpointLocationKey addrEndpointLocationKey =
- new AddressEndpointLocationKey(IP_ADDRESS, IpPrefixType.class, l3Context,
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class);
+ new AddressEndpointLocationKey(IP_ADDRESS, AddressType.class, l3Context, ContextType.class);
InstanceIdentifier<AbsoluteLocation> iid = IidFactory.absoluteLocationIid(addrEndpointLocationKey);
- Assert.assertEquals(IpPrefixType.class, iid.firstKeyOf(AddressEndpointLocation.class).getAddressType());
+ Assert.assertEquals(AddressType.class, iid.firstKeyOf(AddressEndpointLocation.class).getAddressType());
Assert.assertEquals(IP_ADDRESS, iid.firstKeyOf(AddressEndpointLocation.class).getAddress());
- Assert.assertEquals(
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context.class,
- iid.firstKeyOf(AddressEndpointLocation.class).getContextType());
+ Assert.assertEquals(ContextType.class, iid.firstKeyOf(AddressEndpointLocation.class).getContextType());
Assert.assertEquals(l3Context, iid.firstKeyOf(AddressEndpointLocation.class).getContextId());
}
}
<packaging>bundle</packaging>
<dependencies>
+ <dependency>
+ <groupId>org.opendaylight.groupbasedpolicy</groupId>
+ <artifactId>l2-l3-domain-extension</artifactId>
+ <version>${project.version}</version>
+ </dependency>
<!-- testing dependencies -->
<dependency>
<groupId>junit</groupId>
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
import org.opendaylight.groupbasedpolicy.util.IidFactory;
import org.opendaylight.groupbasedpolicy.util.NetUtils;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.AbsoluteLocation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.AbsoluteLocationBuilder;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.InternalLocationCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.ExternalLocationCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.NetworkElements;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.NetworkElementsBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.network.elements.NetworkElement;
}
public synchronized void onEndpointsChange(Collection<DataTreeModification<AddressEndpoint>> changes) {
+ WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
for (DataTreeModification<AddressEndpoint> change : changes) {
switch (change.getRootNode().getModificationType()) {
case DELETE: {
AddressEndpoint endpoint = change.getRootNode().getDataBefore();
- removeLocationForEndpoint(endpoint);
+ removeLocationForEndpoint(endpoint, wtx);
this.endpoints.remove(endpoint);
break;
}
break;
}
endpoint = change.getRootNode().getDataAfter();
- createLocationForEndpoint(endpoint);
+ createLocationForEndpoint(endpoint, wtx);
this.endpoints.add(endpoint);
break;
}
}
}
}
+ DataStoreHelper.submitToDs(wtx);
}
- private void createLocationForEndpoint(AddressEndpoint endpoint) {
+ private void createLocationForEndpoint(AddressEndpoint endpoint, WriteTransaction wtx) {
for (NetworkElement ne : nullToEmpty(networkElements.getNetworkElement())) {
for (Interface iface : nullToEmpty(ne.getInterface())) {
for (EndpointNetwork en : nullToEmpty(iface.getEndpointNetwork())) {
&& endpoint.getContextId().equals(en.getL3ContextId())
&& endpoint.getAddressType().isAssignableFrom(IpPrefixType.class) && NetUtils
.samePrefix(new IpPrefix(endpoint.getAddress().toCharArray()), en.getIpPrefix())) {
- WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
InstanceIdentifier<AbsoluteLocation> iid = IidFactory
.providerAddressEndpointLocationIid(NE_LOCATION_PROVIDER_NAME, IpPrefixType.class,
endpoint.getAddress(), endpoint.getContextType(), endpoint.getContextId())
.child(AbsoluteLocation.class);
wtx.put(LogicalDatastoreType.OPERATIONAL, iid, createRealLocation(ne.getIid(), iface.getIid()),
true);
- wtx.submit();
LOG.debug("New location created for endpoint {}", endpoint);
return;
}
}
}
- private void removeLocationForEndpoint(AddressEndpoint endpoint) {
+ private void removeLocationForEndpoint(AddressEndpoint endpoint, WriteTransaction wtx) {
for (NetworkElement ne : nullToEmpty(networkElements.getNetworkElement())) {
for (Interface iface : nullToEmpty(ne.getInterface())) {
for (EndpointNetwork en : nullToEmpty(iface.getEndpointNetwork())) {
&& endpoint.getContextId().equals(en.getL3ContextId())
&& endpoint.getAddressType().isAssignableFrom(IpPrefixType.class) && NetUtils
.samePrefix(new IpPrefix(endpoint.getAddress().toCharArray()), en.getIpPrefix())) {
- WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
InstanceIdentifier<AbsoluteLocation> iid = IidFactory
.providerAddressEndpointLocationIid(NE_LOCATION_PROVIDER_NAME, IpPrefixType.class,
endpoint.getAddress(), endpoint.getContextType(), endpoint.getContextId())
.child(AbsoluteLocation.class);
wtx.delete(LogicalDatastoreType.OPERATIONAL, iid);
- wtx.submit();
LOG.debug("Location deleted for endpoint {}", endpoint);
return;
}
@Override
public synchronized void onDataTreeChanged(Collection<DataTreeModification<NetworkElements>> changes) {
+ WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
for (DataTreeModification<NetworkElements> change : changes) {
switch (change.getRootNode().getModificationType()) {
case DELETE: {
for (NetworkElement ne : nullToEmpty(nes.getNetworkElement())) {
for (Interface iface : nullToEmpty(ne.getInterface())) {
for (EndpointNetwork en : nullToEmpty(iface.getEndpointNetwork())) {
- processDeletedEN(en);
+ processDeletedEN(en, wtx);
}
}
}
for (NetworkElement ne : nullToEmpty(nes.getNetworkElement())) {
for (Interface iface : nullToEmpty(ne.getInterface())) {
for (EndpointNetwork en : nullToEmpty(iface.getEndpointNetwork())) {
- processDeletedEN(en);
+ processDeletedEN(en, wtx);
}
}
}
for (NetworkElement ne : nullToEmpty(nes.getNetworkElement())) {
for (Interface iface : nullToEmpty(ne.getInterface())) {
for (EndpointNetwork en : nullToEmpty(iface.getEndpointNetwork())) {
- processCreatedEN(en, ne.getIid(), iface.getIid());
+ processCreatedEN(en, ne.getIid(), iface.getIid(), wtx);
}
}
}
List<DataObjectModification<NetworkElement>> modifiedNetworkElements =
getModifiedNetworkElements(change.getRootNode());
for (DataObjectModification<NetworkElement> netElement : modifiedNetworkElements) {
- processNetworkElementChange(netElement);
+ processNetworkElementChange(netElement, wtx);
}
break;
}
}
}
+ DataStoreHelper.submitToDs(wtx);
}
private List<DataObjectModification<NetworkElement>> getModifiedNetworkElements(
return nes;
}
- private void processNetworkElementChange(DataObjectModification<NetworkElement> netElement) {
+ private void processNetworkElementChange(DataObjectModification<NetworkElement> netElement, WriteTransaction wtx) {
switch (netElement.getModificationType()) {
case DELETE: {
NetworkElement ne = netElement.getDataBefore();
for (Interface iface : nullToEmpty(ne.getInterface())) {
for (EndpointNetwork en : nullToEmpty(iface.getEndpointNetwork())) {
- processDeletedEN(en);
+ processDeletedEN(en, wtx);
}
}
networkElements.getNetworkElement().remove(ne);
if (ne != null) {
for (Interface iface : nullToEmpty(ne.getInterface())) {
for (EndpointNetwork en : nullToEmpty(iface.getEndpointNetwork())) {
- processDeletedEN(en);
+ processDeletedEN(en, wtx);
}
}
networkElements.getNetworkElement().remove(ne);
ne = netElement.getDataAfter();
for (Interface iface : nullToEmpty(ne.getInterface())) {
for (EndpointNetwork en : nullToEmpty(iface.getEndpointNetwork())) {
- processCreatedEN(en, ne.getIid(), iface.getIid());
+ processCreatedEN(en, ne.getIid(), iface.getIid(), wtx);
}
}
networkElements.getNetworkElement().add(ne);
case SUBTREE_MODIFIED: {
List<DataObjectModification<Interface>> modifiedInterfaces = getModifiedInterfaces(netElement);
for (DataObjectModification<Interface> modifiedInterface : modifiedInterfaces) {
- processInterfaceChange(modifiedInterface, netElement.getDataBefore());
+ processInterfaceChange(modifiedInterface, netElement.getDataBefore(), wtx);
}
break;
}
}
private void processInterfaceChange(DataObjectModification<Interface> modifiedInterface,
- NetworkElement nodeBefore) {
+ NetworkElement nodeBefore, WriteTransaction wtx) {
switch (modifiedInterface.getModificationType()) {
case DELETE: {
Interface iface = modifiedInterface.getDataBefore();
for (EndpointNetwork en : nullToEmpty(iface.getEndpointNetwork())) {
- processDeletedEN(en);
+ processDeletedEN(en, wtx);
}
int nodeIndex = getIndexOf(nodeBefore);
networkElements.getNetworkElement().get(nodeIndex).getInterface().remove(iface);
int nodeIndex = getIndexOf(nodeBefore);
if (iface != null) {
for (EndpointNetwork en : nullToEmpty(iface.getEndpointNetwork())) {
- processDeletedEN(en);
+ processDeletedEN(en, wtx);
}
networkElements.getNetworkElement().get(nodeIndex).getInterface().remove(iface);
}
iface = modifiedInterface.getDataAfter();
for (EndpointNetwork en : nullToEmpty(iface.getEndpointNetwork())) {
- processCreatedEN(en, nodeBefore.getIid(), iface.getIid());
+ processCreatedEN(en, nodeBefore.getIid(), iface.getIid(), wtx);
}
networkElements.getNetworkElement().get(nodeIndex).getInterface().add(iface);
LOG.debug("Created new Interface {}", modifiedInterface.getDataAfter());
List<DataObjectModification<EndpointNetwork>> modifiedENs =
getModifiedEndpointNetworks(modifiedInterface);
for (DataObjectModification<EndpointNetwork> modifiedEN : modifiedENs) {
- processEndpointNetworkChange(modifiedEN, nodeBefore, modifiedInterface.getDataBefore());
+ processEndpointNetworkChange(modifiedEN, nodeBefore, modifiedInterface.getDataBefore(), wtx);
}
break;
}
}
private void processEndpointNetworkChange(DataObjectModification<EndpointNetwork> modifiedEN,
- NetworkElement nodeBefore, Interface ifaceBefore) {
+ NetworkElement nodeBefore, Interface ifaceBefore, WriteTransaction wtx) {
switch (modifiedEN.getModificationType()) {
case DELETE: {
- processDeletedEN(modifiedEN.getDataBefore());
+ processDeletedEN(modifiedEN.getDataBefore(), wtx);
int nodeIndex = getIndexOf(nodeBefore);
int ifaceIndex = getIndexOf(ifaceBefore, nodeIndex);
networkElements.getNetworkElement()
break;
}
case WRITE: {
- processCreatedEN(modifiedEN.getDataAfter(), nodeBefore.getIid(), ifaceBefore.getIid());
+ processCreatedEN(modifiedEN.getDataAfter(), nodeBefore.getIid(), ifaceBefore.getIid(), wtx);
int nodeIndex = getIndexOf(nodeBefore);
int ifaceIndex = getIndexOf(ifaceBefore, nodeIndex);
networkElements.getNetworkElement()
}
private void processCreatedEN(EndpointNetwork en, InstanceIdentifier<?> nodeIID,
- InstanceIdentifier<?> connectorIID) {
- WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
+ InstanceIdentifier<?> connectorIID, WriteTransaction wtx) {
for (AddressEndpoint endpoint : endpoints) {
if (endpoint.getContextType().isAssignableFrom(L3Context.class)
&& endpoint.getContextId().equals(en.getL3ContextId())
endpoint.getAddress(), endpoint.getContextType(), endpoint.getContextId())
.child(AbsoluteLocation.class);
wtx.put(LogicalDatastoreType.OPERATIONAL, iid, createRealLocation(nodeIID, connectorIID), true);
- wtx.submit();
LOG.debug("New location created for endpoint {}", endpoint);
return;
}
}
}
- private void processDeletedEN(EndpointNetwork en) {
- WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
+ private void processDeletedEN(EndpointNetwork en, WriteTransaction wtx) {
for (AddressEndpoint endpoint : endpoints) {
if (endpoint.getContextType().isAssignableFrom(L3Context.class)
&& endpoint.getContextId().equals(en.getL3ContextId())
endpoint.getAddress(), endpoint.getContextType(), endpoint.getContextId())
.child(AbsoluteLocation.class);
wtx.delete(LogicalDatastoreType.OPERATIONAL, iid);
- wtx.submit();
LOG.debug("Location deleted for endpoint {}", endpoint);
return;
}
private AbsoluteLocation createRealLocation(InstanceIdentifier<?> node, InstanceIdentifier<?> iface) {
return new AbsoluteLocationBuilder()
- .setLocationType(new InternalLocationCaseBuilder().setInternalNode(node).setInternalNodeConnector(iface).build()).build();
+ .setLocationType(new ExternalLocationCaseBuilder().setExternalNodeMountPoint(node)
+ .setExternalNodeConnector(iface.toString()).build()).build();
}
private <T> List<T> nullToEmpty(@Nullable List<T> list) {
import org.opendaylight.groupbasedpolicy.util.IidFactory;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Prefix;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.EndpointLocations;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.Endpoints;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.NetworkContainment;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.common.endpoint.fields.NetworkContainmentBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpoint;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.endpoints.address.endpoints.AddressEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.AbsoluteLocationBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.ExternalLocationCaseBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContextId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.NetworkDomainId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.NetworkElements;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.network.elements.network.element._interface.EndpointNetwork;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.network.elements.network.element._interface.EndpointNetworkBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.network.elements.rev160407.network.elements.network.element._interface.EndpointNetworkKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.LocationProviders;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.LocationProvidersBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.ProviderName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.LocationProviderBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.location.provider.ProviderAddressEndpointLocationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.IpPrefixType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.L3Context;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.AddressType;
private DataBroker dataBroker;
private NeLocationProvider neProvider;
private String L3_CONTEXT_ID = "l3Context";
- private String IPv4_HOST_ADDRESS_1 = "192.168.50.71";
- private String IPv4_HOST_ADDRESS_2 = "192.168.50.72";
+ private String IPv4_HOST_ADDRESS_1 = "192.168.50.71/24";
+ private String IPv4_HOST_ADDRESS_2 = "192.168.50.72/24";
private String IPv4_NETWORK_ADDRESS_1 = "192.168.50.0/24";
private String IPv4_NETWORK_ADDRESS_2 = "192.168.51.0/24";
private String NODE_ID_1 = "node1";
@Override
public Collection<Class<?>> getClassesFromModules() {
- return ImmutableList.<Class<?>>of(NetworkElements.class, EndpointLocations.class, Endpoints.class, L3Context.class, Nodes.class);
+ return ImmutableList.<Class<?>>of(NetworkElements.class, LocationProviders.class, Endpoints.class, L3Context.class, Nodes.class);
}
@Before
@Test
public void test_AddressEndpointWrite_NoNE_NoOverwrite() throws Exception {
- AddressEndpoint endpoint =
- createAddressEndpoint(IPv4_HOST_ADDRESS_1, IpPrefixType.class, L3_CONTEXT_ID, L3Context.class);
+ AddressEndpoint endpoint = writeBaseAddrEndpoint();
+ List<AddressEndpoint> endpoints = neProvider.getEndpoints();
+ assertEquals(1, endpoints.size());
+ assertEquals(endpoint, endpoints.get(0));
+ verifyEmptyLocations();
+ }
+
+ @Test
+ public void test_AddressEndpointWrite_NoNE_Overwrite() throws Exception {
+ writeBaseAddrEndpoint();
+ NetworkContainment nc = new NetworkContainmentBuilder()
+ .setContainment(new NetworkDomainContainmentBuilder().setNetworkDomainId(new NetworkDomainId(L3_CONTEXT_ID)).build())
+ .build();
+ AddressEndpoint endpoint = new AddressEndpointBuilder().setKey(
+ new AddressEndpointKey(IPv4_HOST_ADDRESS_1, IpPrefixType.class, new ContextId(L3_CONTEXT_ID), L3Context.class))
+ .setNetworkContainment(nc)
+ .build();
InstanceIdentifier<AddressEndpoint> iid = IidFactory.addressEndpointIid(endpoint.getKey());
WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
wtx.put(LogicalDatastoreType.OPERATIONAL, iid, endpoint, true);
}
@Test
- public void test_AddressEndpointWrite_NoNE_Overwrite() throws Exception {
- test_AddressEndpointWrite_NoNE_NoOverwrite();
+ public void test_AddressEndpointModified_NoNE() throws Exception {
+ writeBaseAddrEndpoint();
NetworkContainment nc = new NetworkContainmentBuilder()
.setContainment(new NetworkDomainContainmentBuilder().setNetworkDomainId(new NetworkDomainId(L3_CONTEXT_ID)).build())
.build();
@Test
public void test_EndpointsDelete_NoNE() throws Exception {
- test_AddressEndpointWrite_NoNE_NoOverwrite();
+ writeBaseAddrEndpoint();
InstanceIdentifier<Endpoints> iid = InstanceIdentifier.builder(Endpoints.class)
.build();
WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
@Test
public void test_EndpointsModify_NoNE() throws Exception {
- test_AddressEndpointWrite_NoNE_NoOverwrite();
+ writeBaseAddrEndpoint();
InstanceIdentifier<Endpoints> iid = InstanceIdentifier.builder(Endpoints.class)
.build();
WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
@Test
public void test_NetworkElementsWrite_NoEP_NoOverwrite() throws Exception {
- NetworkElements nes = createNetworkElements(NODE_ID_1, CONNECTOR_ID_1, L3_CONTEXT_ID, IPv4_NETWORK_ADDRESS_1);
- InstanceIdentifier<NetworkElements> iid = InstanceIdentifier.builder(NetworkElements.class).build();
- WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
- wtx.put(LogicalDatastoreType.CONFIGURATION, iid, nes);
- wtx.submit().get();
+ NetworkElements nes = writeBaseNetworkElements();
NetworkElements networkElements = neProvider.getNetworkElements();
assertEquals(nes, networkElements);
verifyEmptyLocations();
@Test
public void test_NetworkElementsWrite_NoEP_Overwrite() throws Exception {
- test_NetworkElementsWrite_NoEP_NoOverwrite();
+ writeBaseNetworkElements();
NetworkElements nes = createNetworkElements(NODE_ID_2, CONNECTOR_ID_2, L3_CONTEXT_ID, IPv4_NETWORK_ADDRESS_1);
InstanceIdentifier<NetworkElements> iid = InstanceIdentifier.builder(NetworkElements.class).build();
WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
@Test
public void test_NetworkElementWrite_NoEP_Overwrite() throws Exception {
- test_NetworkElementsWrite_NoEP_NoOverwrite();
+ writeBaseNetworkElements();
NetworkElement ne = createNetworkElement(NODE_ID_1, CONNECTOR_ID_1, L3_CONTEXT_ID, IPv4_NETWORK_ADDRESS_2);
InstanceIdentifier<NetworkElement> iid = InstanceIdentifier.builder(NetworkElements.class)
.child(NetworkElement.class, new NetworkElementKey(ne.getKey()))
@Test
public void test_InterfaceWrite_NoEP_Overwrite() throws Exception {
- test_NetworkElementsWrite_NoEP_NoOverwrite();
+ writeBaseNetworkElements();
Interface iface = createInterface(NODE_ID_1, CONNECTOR_ID_1, L3_CONTEXT_ID, IPv4_NETWORK_ADDRESS_2);
InstanceIdentifier<Interface> iid = InstanceIdentifier.builder(NetworkElements.class)
.child(NetworkElement.class, new NetworkElementKey(createNetworkElementIid(NODE_ID_1)))
@Test
public void test_EndpointNetworkChange_NoEP() throws Exception {
- test_NetworkElementsWrite_NoEP_NoOverwrite();
+ writeBaseNetworkElements();
EndpointNetwork en = createEndpointNetwork(L3_CONTEXT_ID, IPv4_NETWORK_ADDRESS_2);
InstanceIdentifier<EndpointNetwork> iid = InstanceIdentifier.builder(NetworkElements.class)
.child(NetworkElement.class, new NetworkElementKey(createNetworkElementIid(NODE_ID_1)))
@Test
public void test_NetworkElementsDelete() throws Exception {
- test_NetworkElementsWrite_NoEP_NoOverwrite();
+ writeBaseNetworkElements();
InstanceIdentifier<NetworkElements> iid = InstanceIdentifier.builder(NetworkElements.class).build();
WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
wtx.delete(LogicalDatastoreType.CONFIGURATION, iid);
@Test
public void test_NetworkElementDelete() throws Exception {
- test_NetworkElementsWrite_NoEP_NoOverwrite();
+ writeBaseNetworkElements();
InstanceIdentifier<NetworkElement> iid = InstanceIdentifier.builder(NetworkElements.class)
.child(NetworkElement.class, new NetworkElementKey(createNetworkElementIid(NODE_ID_1)))
.build();
@Test
public void test_InterfaceDelete() throws Exception {
- test_NetworkElementsWrite_NoEP_NoOverwrite();
+ writeBaseNetworkElements();
InstanceIdentifier<Interface> iid = InstanceIdentifier.builder(NetworkElements.class)
.child(NetworkElement.class, new NetworkElementKey(createNetworkElementIid(NODE_ID_1)))
.child(Interface.class, new InterfaceKey(createInterfaceIid(NODE_ID_1, CONNECTOR_ID_1)))
verifyEmptyLocations();
}
+ @Test
+ public void test_CreateLocationForAddrEndpoint_EndpointWriteFirst() throws Exception {
+ AddressEndpoint endpoint =
+ createAddressEndpoint(IPv4_HOST_ADDRESS_1, IpPrefixType.class, L3_CONTEXT_ID, L3Context.class);
+ InstanceIdentifier<AddressEndpoint> iid = IidFactory.addressEndpointIid(endpoint.getKey());
+ WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
+ wtx.put(LogicalDatastoreType.OPERATIONAL, iid, endpoint, true);
+ wtx.submit().get();
+
+ NetworkElements nes = createNetworkElements(NODE_ID_1, CONNECTOR_ID_1, L3_CONTEXT_ID, IPv4_NETWORK_ADDRESS_1);
+ InstanceIdentifier<NetworkElements> neIid = InstanceIdentifier.builder(NetworkElements.class).build();
+ wtx = dataBroker.newWriteOnlyTransaction();
+ wtx.put(LogicalDatastoreType.CONFIGURATION, neIid, nes);
+ wtx.submit().get();
+
+ ReadOnlyTransaction rtx = dataBroker.newReadOnlyTransaction();
+ InstanceIdentifier<LocationProviders> locationIid = InstanceIdentifier.builder(LocationProviders.class).build();
+ CheckedFuture<Optional<LocationProviders>, ReadFailedException> read =
+ rtx.read(LogicalDatastoreType.OPERATIONAL, locationIid);
+ assertTrue(read.get().isPresent());
+ rtx.close();
+ LocationProviders locations = read.get().get();
+ LocationProviders locationReference =
+ new LocationProvidersBuilder()
+ .setLocationProvider(Collections.singletonList(new LocationProviderBuilder()
+ .setProvider(new ProviderName(NeLocationProvider.NE_LOCATION_PROVIDER_NAME))
+ .setProviderAddressEndpointLocation(Collections.singletonList(
+ new ProviderAddressEndpointLocationBuilder()
+ .setAddress(IPv4_HOST_ADDRESS_1)
+ .setAddressType(IpPrefixType.class)
+ .setContextId(new ContextId(L3_CONTEXT_ID))
+ .setContextType(L3Context.class)
+ .setAbsoluteLocation(new AbsoluteLocationBuilder()
+ .setLocationType(new ExternalLocationCaseBuilder()
+ .setExternalNodeMountPoint(createNetworkElementIid(NODE_ID_1))
+ .setExternalNodeConnector(createInterfaceIid(
+ NODE_ID_1, CONNECTOR_ID_1).toString())
+ .build())
+ .build())
+ .build()))
+ .build()))
+ .build();
+ assertEquals(locationReference, locations);
+ }
+
+ @Test
+ public void test_CreateLocationForAddrEndpoint_NEWriteFirst() throws Exception {
+ NetworkElements nes = createNetworkElements(NODE_ID_1, CONNECTOR_ID_1, L3_CONTEXT_ID, IPv4_NETWORK_ADDRESS_1);
+ InstanceIdentifier<NetworkElements> neIid = InstanceIdentifier.builder(NetworkElements.class).build();
+ WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
+ wtx.put(LogicalDatastoreType.CONFIGURATION, neIid, nes);
+
+ AddressEndpoint endpoint =
+ createAddressEndpoint(IPv4_HOST_ADDRESS_1, IpPrefixType.class, L3_CONTEXT_ID, L3Context.class);
+ InstanceIdentifier<AddressEndpoint> iid = IidFactory.addressEndpointIid(endpoint.getKey());
+ wtx.put(LogicalDatastoreType.OPERATIONAL, iid, endpoint, true);
+ wtx.submit().get();
+
+ ReadOnlyTransaction rtx = dataBroker.newReadOnlyTransaction();
+ InstanceIdentifier<LocationProviders> locationIid = InstanceIdentifier.builder(LocationProviders.class).build();
+ CheckedFuture<Optional<LocationProviders>, ReadFailedException> read =
+ rtx.read(LogicalDatastoreType.OPERATIONAL, locationIid);
+ assertTrue(read.get().isPresent());
+ rtx.close();
+ LocationProviders locations = read.get().get();
+ LocationProviders locationReference =
+ new LocationProvidersBuilder()
+ .setLocationProvider(Collections.singletonList(new LocationProviderBuilder()
+ .setProvider(new ProviderName(NeLocationProvider.NE_LOCATION_PROVIDER_NAME))
+ .setProviderAddressEndpointLocation(Collections.singletonList(
+ new ProviderAddressEndpointLocationBuilder()
+ .setAddress(IPv4_HOST_ADDRESS_1)
+ .setAddressType(IpPrefixType.class)
+ .setContextId(new ContextId(L3_CONTEXT_ID))
+ .setContextType(L3Context.class)
+ .setAbsoluteLocation(new AbsoluteLocationBuilder()
+ .setLocationType(new ExternalLocationCaseBuilder()
+ .setExternalNodeMountPoint(createNetworkElementIid(NODE_ID_1))
+ .setExternalNodeConnector(createInterfaceIid(
+ NODE_ID_1, CONNECTOR_ID_1).toString())
+ .build())
+ .build())
+ .build()))
+ .build()))
+ .build();
+ assertEquals(locationReference, locations);
+ }
+
+ @Test
+ public void test_CreateLocationForAddrEndpoint_SimultaneousWrite() throws Exception {
+ NetworkElements nes = createNetworkElements(NODE_ID_1, CONNECTOR_ID_1, L3_CONTEXT_ID, IPv4_NETWORK_ADDRESS_1);
+ InstanceIdentifier<NetworkElements> neIid = InstanceIdentifier.builder(NetworkElements.class).build();
+ WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
+ wtx.put(LogicalDatastoreType.CONFIGURATION, neIid, nes);
+ wtx.submit().get();
+
+ AddressEndpoint endpoint =
+ createAddressEndpoint(IPv4_HOST_ADDRESS_1, IpPrefixType.class, L3_CONTEXT_ID, L3Context.class);
+ InstanceIdentifier<AddressEndpoint> iid = IidFactory.addressEndpointIid(endpoint.getKey());
+ wtx = dataBroker.newWriteOnlyTransaction();
+ wtx.put(LogicalDatastoreType.OPERATIONAL, iid, endpoint, true);
+ wtx.submit().get();
+
+ ReadOnlyTransaction rtx = dataBroker.newReadOnlyTransaction();
+ InstanceIdentifier<LocationProviders> locationIid = InstanceIdentifier.builder(LocationProviders.class).build();
+ CheckedFuture<Optional<LocationProviders>, ReadFailedException> read =
+ rtx.read(LogicalDatastoreType.OPERATIONAL, locationIid);
+ assertTrue(read.get().isPresent());
+ rtx.close();
+ LocationProviders locations = read.get().get();
+ LocationProviders locationReference =
+ new LocationProvidersBuilder()
+ .setLocationProvider(Collections.singletonList(new LocationProviderBuilder()
+ .setProvider(new ProviderName(NeLocationProvider.NE_LOCATION_PROVIDER_NAME))
+ .setProviderAddressEndpointLocation(Collections.singletonList(
+ new ProviderAddressEndpointLocationBuilder()
+ .setAddress(IPv4_HOST_ADDRESS_1)
+ .setAddressType(IpPrefixType.class)
+ .setContextId(new ContextId(L3_CONTEXT_ID))
+ .setContextType(L3Context.class)
+ .setAbsoluteLocation(new AbsoluteLocationBuilder()
+ .setLocationType(new ExternalLocationCaseBuilder()
+ .setExternalNodeMountPoint(createNetworkElementIid(NODE_ID_1))
+ .setExternalNodeConnector(createInterfaceIid(
+ NODE_ID_1, CONNECTOR_ID_1).toString())
+ .build())
+ .build())
+ .build()))
+ .build()))
+ .build();
+ assertEquals(locationReference, locations);
+ }
+
+ private AddressEndpoint writeBaseAddrEndpoint () throws Exception {
+ AddressEndpoint endpoint =
+ createAddressEndpoint(IPv4_HOST_ADDRESS_1, IpPrefixType.class, L3_CONTEXT_ID, L3Context.class);
+ InstanceIdentifier<AddressEndpoint> iid = IidFactory.addressEndpointIid(endpoint.getKey());
+ WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
+ wtx.put(LogicalDatastoreType.OPERATIONAL, iid, endpoint, true);
+ wtx.submit().get();
+ return endpoint;
+ }
+
+ private NetworkElements writeBaseNetworkElements () throws Exception {
+ NetworkElements nes = createNetworkElements(NODE_ID_1, CONNECTOR_ID_1, L3_CONTEXT_ID, IPv4_NETWORK_ADDRESS_1);
+ InstanceIdentifier<NetworkElements> iid = InstanceIdentifier.builder(NetworkElements.class).build();
+ WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
+ wtx.put(LogicalDatastoreType.CONFIGURATION, iid, nes);
+ wtx.submit().get();
+ return nes;
+ }
+
private AddressEndpoint createAddressEndpoint(String ipAddr, Class<? extends AddressType> addrType,
String context, Class<? extends ContextType> cType) {
return new AddressEndpointBuilder().setAddress(ipAddr).setAddressType(addrType)
private void verifyEmptyLocations() throws Exception {
ReadOnlyTransaction rtx = dataBroker.newReadOnlyTransaction();
- InstanceIdentifier<EndpointLocations> locationIid = InstanceIdentifier.builder(EndpointLocations.class).build();
- CheckedFuture<Optional<EndpointLocations>, ReadFailedException> read =
+ InstanceIdentifier<LocationProviders> locationIid = InstanceIdentifier.builder(LocationProviders.class).build();
+ CheckedFuture<Optional<LocationProviders>, ReadFailedException> read =
rtx.read(LogicalDatastoreType.OPERATIONAL, locationIid);
assertFalse(read.get().isPresent());
rtx.close();
<!-- project specific dependencies -->
<dependency>
<groupId>${project.groupId}</groupId>
- <artifactId>groupbasedpolicy</artifactId>
+ <artifactId>l2-l3-domain-extension</artifactId>
<version>${project.version}</version>
+ <type>bundle</type>
</dependency>
<dependency>
<groupId>org.opendaylight.neutron</groupId>
public class NeutronMapper implements DataTreeChangeListener<Neutron>, AutoCloseable {
private final static SecurityRuleBuilder EIG_INGRESS_IPV4_SEC_RULE_BUILDER = new SecurityRuleBuilder()
- .setId(new Uuid("19b85ad2-bdfc-11e5-9912-ba0be0483c18"))
+ .setId(new Uuid("0a629f80-2408-11e6-b67b-9e71128cae77"))
.setDirection(DirectionIngress.class)
.setEthertype(EthertypeV4.class)
.setSecurityGroupId(MappingUtils.EIG_UUID);
private final static SecurityRuleBuilder EIG_EGRESS_IPV4_SEC_RULE_BUILDER = new SecurityRuleBuilder()
- .setId(new Uuid("19b85ad2-bdfc-11e5-9912-ba0be0483c18"))
+ .setId(new Uuid("0f1789be-2408-11e6-b67b-9e71128cae77"))
.setDirection(DirectionEgress.class)
.setEthertype(EthertypeV4.class)
.setSecurityGroupId(MappingUtils.EIG_UUID);
private final static SecurityRuleBuilder EIG_INGRESS_IPV6_SEC_RULE_BUILDER = new SecurityRuleBuilder()
- .setId(new Uuid("19b85ad2-bdfc-11e5-9912-ba0be0483c18"))
+ .setId(new Uuid("139b7f90-2408-11e6-b67b-9e71128cae77"))
.setDirection(DirectionIngress.class)
.setEthertype(EthertypeV6.class)
.setSecurityGroupId(MappingUtils.EIG_UUID);
private final static SecurityRuleBuilder EIG_EGRESS_IPV6_SEC_RULE_BUILDER = new SecurityRuleBuilder()
- .setId(new Uuid("19b85ad2-bdfc-11e5-9912-ba0be0483c18"))
+ .setId(new Uuid("17517202-2408-11e6-b67b-9e71128cae77"))
.setDirection(DirectionEgress.class)
.setEthertype(EthertypeV6.class)
.setSecurityGroupId(MappingUtils.EIG_UUID);
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.domain_extension.l2_l3.util.L2L3IidFactory;
import org.opendaylight.groupbasedpolicy.neutron.gbp.util.NeutronGbpIidFactory;
import org.opendaylight.groupbasedpolicy.neutron.mapper.infrastructure.NetworkClient;
import org.opendaylight.groupbasedpolicy.neutron.mapper.infrastructure.NetworkService;
MappingUtils.createParent(ctxId, MappingUtils.L2_BRDIGE_DOMAIN));
ForwardingContext l2Fd = fwdCtxBuilder.build();
- rwTx.put(LogicalDatastoreType.CONFIGURATION, IidFactory.l3ContextIid(tenantId, ctxId), l3Context, true);
- rwTx.put(LogicalDatastoreType.CONFIGURATION, IidFactory.l2BridgeDomainIid(tenantId, ctxId), l2Bd, true);
- rwTx.put(LogicalDatastoreType.CONFIGURATION, IidFactory.l2FloodDomainIid(tenantId, ctxId), l2Fd, true);
+ rwTx.put(LogicalDatastoreType.CONFIGURATION, L2L3IidFactory.l3ContextIid(tenantId, ctxId), l3Context, true);
+ rwTx.put(LogicalDatastoreType.CONFIGURATION, L2L3IidFactory.l2BridgeDomainIid(tenantId, ctxId), l2Bd, true);
+ rwTx.put(LogicalDatastoreType.CONFIGURATION, L2L3IidFactory.l2FloodDomainIid(tenantId, ctxId), l2Fd, true);
createTenantNetworkDomains(network, tenantId, rwTx);
TenantId tenantId = new TenantId(network.getTenantId().getValue());
ContextId id = new ContextId(network.getUuid().getValue());
Optional<ForwardingContext> potentialL2Fd = DataStoreHelper.removeIfExists(LogicalDatastoreType.CONFIGURATION,
- IidFactory.l2FloodDomainIid(tenantId, id), rwTx);
+ L2L3IidFactory.l2FloodDomainIid(tenantId, id), rwTx);
if (!potentialL2Fd.isPresent()) {
LOG.warn("Illegal state - l2-flood-domain {} does not exist.", id.getValue());
return;
}
Optional<ForwardingContext> potentialL2Bd = DataStoreHelper.removeIfExists(LogicalDatastoreType.CONFIGURATION,
- IidFactory.l2BridgeDomainIid(tenantId, id), rwTx);
+ L2L3IidFactory.l2BridgeDomainIid(tenantId, id), rwTx);
if (!potentialL2Bd.isPresent()) {
LOG.warn("Illegal state - l2-bridge-domain {} does not exist.", id.getValue());
return;
}
Optional<ForwardingContext> potentialL3Ctx = DataStoreHelper.removeIfExists(LogicalDatastoreType.CONFIGURATION,
- IidFactory.l3ContextIid(tenantId, id), rwTx);
+ L2L3IidFactory.l3ContextIid(tenantId, id), rwTx);
if (!potentialL3Ctx.isPresent()) {
LOG.warn("Illegal state - l3-context {} does not exist.", id.getValue());
return;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.domain_extension.l2_l3.util.L2L3IidFactory;
import org.opendaylight.groupbasedpolicy.neutron.gbp.util.NeutronGbpIidFactory;
import org.opendaylight.groupbasedpolicy.neutron.mapper.EndpointRegistrator;
import org.opendaylight.groupbasedpolicy.neutron.mapper.infrastructure.NetworkClient;
.setContextType(MappingUtils.L2_BRDIGE_DOMAIN)
.setParent(MappingUtils.createParent(routerL3Context, MappingUtils.L3_CONTEXT))
.build();
- rwTx.merge(LogicalDatastoreType.CONFIGURATION, IidFactory.l2BridgeDomainIid(tenantId, l2BdId), l2Bd);
+ rwTx.merge(LogicalDatastoreType.CONFIGURATION, L2L3IidFactory.l2BridgeDomainIid(tenantId, l2BdId), l2Bd);
// set virtual router IP for subnet
NetworkDomain subnetDomain = NeutronSubnetAware.createSubnet(
routerPortSubnet, portIpWithSubnet.getIpAddress());
- rwTx.merge(LogicalDatastoreType.CONFIGURATION, IidFactory.subnetIid(tenantId, subnetDomain.getNetworkDomainId()), subnetDomain);
+ rwTx.merge(LogicalDatastoreType.CONFIGURATION, L2L3IidFactory.subnetIid(tenantId, subnetDomain.getNetworkDomainId()), subnetDomain);
// does the same for tenant forwarding domains
processTenantForwarding(routerPortSubnet, routerL3Context, portIpWithSubnet, tenantId, rwTx);
.setParent(MappingUtils.createParent(l3Context, MappingUtils.L3_CONTEXT))
.build();
rwTx.merge(LogicalDatastoreType.CONFIGURATION,
- IidFactory.l2BridgeDomainIid(tenantId, fwdCtx.getContextId()), fwdCtx);
+ L2L3IidFactory.l2BridgeDomainIid(tenantId, fwdCtx.getContextId()), fwdCtx);
NetworkDomain subnet = NeutronSubnetAware.createSubnet(routerPortSubnet, null);
- rwTx.put(LogicalDatastoreType.CONFIGURATION, IidFactory.subnetIid(tenantId, subnet.getNetworkDomainId()),
+ rwTx.put(LogicalDatastoreType.CONFIGURATION, L2L3IidFactory.subnetIid(tenantId, subnet.getNetworkDomainId()),
subnet);
DataStoreHelper.submitToDs(rwTx);
} else if (PortUtils.isDhcpPort(port)) {
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.domain_extension.l2_l3.util.L2L3IidFactory;
import org.opendaylight.groupbasedpolicy.neutron.gbp.util.NeutronGbpIidFactory;
import org.opendaylight.groupbasedpolicy.neutron.mapper.EndpointRegistrator;
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.MappingUtils;
ContextId routerl3ContextId = new ContextId(router.getUuid().getValue());
TenantId tenantId = new TenantId(router.getTenantId().getValue());
- InstanceIdentifier<ForwardingContext> routerL3CtxIid = IidFactory.l3ContextIid(tenantId, routerl3ContextId);
+ InstanceIdentifier<ForwardingContext> routerL3CtxIid = L2L3IidFactory.l3ContextIid(tenantId, routerl3ContextId);
ForwardingContextBuilder fwdCtxBuilder = new ForwardingContextBuilder();
Name routerName = null;
if (!Strings.isNullOrEmpty(router.getName())) {
addNeutronExtGwGbpMapping(routerL3CtxId, gatewayIp, rwTx);
NetworkDomain subnetDomain = createSubnetWithVirtualRouterIp(gatewayIp, new NetworkDomainId(ipWithSubnetFromGwPort.getSubnetId()
.getValue()));
- rwTx.merge(LogicalDatastoreType.CONFIGURATION, IidFactory.subnetIid(tenantId, subnetDomain.getNetworkDomainId()),
+ rwTx.merge(LogicalDatastoreType.CONFIGURATION, L2L3IidFactory.subnetIid(tenantId, subnetDomain.getNetworkDomainId()),
subnetDomain);
ContextId l2BdId = new ContextId(potentialSubnet.get().getNetworkId().getValue());
Optional<ForwardingContext> optBd = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,
- IidFactory.l2BridgeDomainIid(tenantId, l2BdId), rwTx);
+ L2L3IidFactory.l2BridgeDomainIid(tenantId, l2BdId), rwTx);
if (!optBd.isPresent()) {
LOG.warn(
"Could not read L2-Bridge-Domain {} Modifiaction of it's parent to L3-Context of router {} aborted.",
ForwardingContext l2BdWithGw = new ForwardingContextBuilder(optBd.get())
.setParent(MappingUtils.createParent(routerL3CtxId, MappingUtils.L3_CONTEXT))
.build();
- rwTx.put(LogicalDatastoreType.CONFIGURATION, IidFactory.l2BridgeDomainIid(tenantId, l2BdId),
+ rwTx.put(LogicalDatastoreType.CONFIGURATION, L2L3IidFactory.l2BridgeDomainIid(tenantId, l2BdId),
l2BdWithGw);
}
updateTenantForwarding(newNeutron, oldRouter, newRouter, new L3ContextId(routerL3CtxId), tenantId, rwTx);
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.domain_extension.l2_l3.util.L2L3IidFactory;
import org.opendaylight.groupbasedpolicy.neutron.mapper.EndpointRegistrator;
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.MappingUtils;
import org.opendaylight.groupbasedpolicy.neutron.mapper.util.NetworkUtils;
subnetDomain = createSubnet(neutronSubnet, null);
}
processTenantSubnet(neutronSubnet, networkOfSubnet, tenantId, rwTx);
- rwTx.put(LogicalDatastoreType.CONFIGURATION, IidFactory.subnetIid(tenantId, subnetDomain.getNetworkDomainId()), subnetDomain, true);
+ rwTx.put(LogicalDatastoreType.CONFIGURATION, L2L3IidFactory.subnetIid(tenantId, subnetDomain.getNetworkDomainId()), subnetDomain, true);
DataStoreHelper.submitToDs(rwTx);
}
NetworkDomainId subnetId = new NetworkDomainId(neutronSubnet.getUuid().getValue());
TenantId tenantId = new TenantId(neutronSubnet.getTenantId().getValue());
Optional<NetworkDomain> potentialSubnetDomain = DataStoreHelper.removeIfExists(LogicalDatastoreType.CONFIGURATION,
- IidFactory.subnetIid(tenantId, subnetId), rwTx);
+ L2L3IidFactory.subnetIid(tenantId, subnetId), rwTx);
if (!potentialSubnetDomain.isPresent()) {
LOG.warn("Illegal state - subnet network domain {} does not exist.", subnetId.getValue());
rwTx.cancel();
if (external == null) {
return false;
}
- return true;
+ return external;
}
public static @Nonnull String getPhysicalNetwork(Network network) {
--- /dev/null
+<?xml version="1.0"?>
+<!-- Copyright (c) 2015 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 -->
+<project
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
+ xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>config-parent</artifactId>
+ <version>0.5.0-SNAPSHOT</version>
+ <relativePath/>
+ </parent>
+
+ <groupId>org.opendaylight.groupbasedpolicy</groupId>
+ <artifactId>neutron-vpp-mapper</artifactId>
+ <version>0.4.0-SNAPSHOT</version>
+ <packaging>bundle</packaging>
+
+ <properties>
+ <neutron.version>0.7.0-SNAPSHOT</neutron.version>
+ </properties>
+
+ <dependencies>
+ <!-- project specific dependencies -->
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>groupbasedpolicy</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>${project.groupId}</groupId>
+ <artifactId>neutron-mapper</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.neutron</groupId>
+ <artifactId>neutron-spi</artifactId>
+ <version>${neutron.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.groupbasedpolicy</groupId>
+ <artifactId>vpp-renderer</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal.model</groupId>
+ <artifactId>ietf-topology</artifactId>
+ </dependency>
+ <!-- testing dependencies -->
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.mockito</groupId>
+ <artifactId>mockito-all</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal-binding-broker-impl</artifactId>
+ <type>test-jar</type>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal.model</groupId>
+ <artifactId>ietf-yang-types-20130715</artifactId>
+ </dependency>
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-bundle-plugin</artifactId>
+ <configuration>
+ <instructions>
+ <!-- <Export-Package>
+ </Export-Package> -->
+ <Import-Package>*</Import-Package>
+ </instructions>
+ </configuration>
+ </plugin>
+ </plugins>
+ </build>
+</project>
\ No newline at end of file
--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Copyright (c) 2014 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
+-->
+<snapshot>
+ <configuration>
+ <data xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
+ <modules xmlns="urn:opendaylight:params:xml:ns:yang:controller:config">
+ <module>
+ <type xmlns:neutron-vpp-mapper="urn:opendaylight:params:xml:ns:yang:controller:config:neutron-vpp-mapper:impl">
+ neutron-vpp-mapper:neutron-vpp-mapper-impl
+ </type>
+ <name>neutron-vpp-mapper-impl</name>
+ <rpc-registry>
+ <type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">binding:binding-rpc-registry</type>
+ <name>binding-rpc-broker</name>
+ </rpc-registry>
+ <data-broker>
+ <type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">binding:binding-async-data-broker</type>
+ <name>binding-data-broker</name>
+ </data-broker>
+ </module>
+ </modules>
+ </data>
+ </configuration>
+ <required-capabilities>
+ <capability>urn:opendaylight:params:xml:ns:yang:controller:config:neutron-vpp-mapper:impl?module=neutron-vpp-mapper-impl&revision=2016-04-25</capability>
+ </required-capabilities>
+</snapshot>
--- /dev/null
+/*
+ * Copyright (c) 2016 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.config.neutron_vpp_mapper.impl;
+
+import org.opendaylight.groupbasedpolicy.neutron.vpp.mapper.NeutronVppMapper;
+
+public class NeutronVppMapperModule extends org.opendaylight.controller.config.yang.config.neutron_vpp_mapper.impl.AbstractNeutronVppMapperModule {
+ public NeutronVppMapperModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) {
+ super(identifier, dependencyResolver);
+ }
+
+ public NeutronVppMapperModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver, org.opendaylight.controller.config.yang.config.neutron_vpp_mapper.impl.NeutronVppMapperModule oldModule, java.lang.AutoCloseable oldInstance) {
+ super(identifier, dependencyResolver, oldModule, oldInstance);
+ }
+
+ @Override
+ public void customValidation() {
+ }
+
+ @Override
+ public java.lang.AutoCloseable createInstance() {
+ String vhostSocketPath = getVhostSocketPath();
+ String vhostSocketPrefix = getVhostSocketPrefix();
+ NeutronVppMapper neutronVppMapper = new NeutronVppMapper(vhostSocketPath, vhostSocketPrefix, getDataBrokerDependency());
+ return neutronVppMapper;
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 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
+ */
+/*
+* Generated file
+*
+* Generated from: yang module name: neutron-vpp-mapper-impl yang module local name: neutron-vpp-mapper-impl
+* Generated by: org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator
+* Generated at: Mon May 02 12:30:34 CEST 2016
+*
+* Do not modify this file unless it is present under src/main directory
+*/
+package org.opendaylight.controller.config.yang.config.neutron_vpp_mapper.impl;
+public class NeutronVppMapperModuleFactory extends org.opendaylight.controller.config.yang.config.neutron_vpp_mapper.impl.AbstractNeutronVppMapperModuleFactory {
+
+}
--- /dev/null
+/*\r
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
+package org.opendaylight.groupbasedpolicy.neutron.vpp.mapper;\r
+\r
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
+import org.opendaylight.groupbasedpolicy.neutron.vpp.mapper.processors.NeutronListener;\r
+import org.slf4j.Logger;\r
+import org.slf4j.LoggerFactory;\r
+\r
+public class NeutronVppMapper implements AutoCloseable {\r
+\r
+ NeutronListener neutronListener;\r
+ private static final Logger LOG = LoggerFactory.getLogger(NeutronVppMapper.class);\r
+\r
+ public NeutronVppMapper(String socketPath, String socketPrefix, DataBroker dataBroker) {\r
+ SocketInfo socketInfo = new SocketInfo(socketPath, socketPrefix);\r
+ neutronListener = new NeutronListener(dataBroker, socketInfo);\r
+ LOG.info("Neutron VPP started!");\r
+ }\r
+\r
+ @Override\r
+ public void close() throws Exception {\r
+ neutronListener.close();\r
+ }\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
+package org.opendaylight.groupbasedpolicy.neutron.vpp.mapper;\r
+\r
+public class SocketInfo {\r
+\r
+ private String socketPath;\r
+ private String socketPrefix;\r
+\r
+ public SocketInfo(String socketPath, String socketPrefix) {\r
+ this.socketPath = socketPath;\r
+ this.socketPrefix = socketPrefix;\r
+ }\r
+\r
+ public String getSocketPath() {\r
+ return socketPath;\r
+ }\r
+\r
+ public String getSocketPrefix() {\r
+ return socketPrefix;\r
+ }\r
+\r
+ @Override\r
+ public int hashCode() {\r
+ final int prime = 31;\r
+ int result = 1;\r
+ result = prime * result + ((socketPath == null) ? 0 : socketPath.hashCode());\r
+ result = prime * result + ((socketPrefix == null) ? 0 : socketPrefix.hashCode());\r
+ return result;\r
+ }\r
+\r
+ @Override\r
+ public boolean equals(Object obj) {\r
+ if (this == obj)\r
+ return true;\r
+ if (obj == null)\r
+ return false;\r
+ if (getClass() != obj.getClass())\r
+ return false;\r
+ SocketInfo other = (SocketInfo) obj;\r
+ if (socketPath == null) {\r
+ if (other.socketPath != null)\r
+ return false;\r
+ } else if (!socketPath.equals(other.socketPath))\r
+ return false;\r
+ if (socketPrefix == null) {\r
+ if (other.socketPrefix != null)\r
+ return false;\r
+ } else if (!socketPrefix.equals(other.socketPrefix))\r
+ return false;\r
+ return true;\r
+ }\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
+package org.opendaylight.groupbasedpolicy.neutron.vpp.mapper.processors;\r
+\r
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;\r
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
+import org.opendaylight.groupbasedpolicy.util.DataTreeChangeHandler;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.Mappings;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.GbpByNeutronMappings;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.BaseEndpointsByPorts;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.base.endpoints.by.ports.BaseEndpointByPort;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
+\r
+public class BaseEndpointByPortListener extends DataTreeChangeHandler<BaseEndpointByPort> implements\r
+ MappingProvider<Port> {\r
+\r
+ private final PortHandler portHandler;\r
+\r
+ protected BaseEndpointByPortListener(PortHandler portHandler, DataBroker dataProvider) {\r
+ super(dataProvider);\r
+ this.portHandler = portHandler;\r
+ registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,\r
+ InstanceIdentifier.builder(Mappings.class)\r
+ .child(GbpByNeutronMappings.class)\r
+ .child(BaseEndpointsByPorts.class)\r
+ .child(BaseEndpointByPort.class)\r
+ .build()));\r
+ }\r
+\r
+ @Override\r
+ public InstanceIdentifier<Port> getNeutronDtoIid() {\r
+ return portHandler.createWildcartedPortIid();\r
+ }\r
+\r
+ @Override\r
+ public void processCreatedNeutronDto(Port port) {\r
+ portHandler.processCreated(port);\r
+ }\r
+\r
+ @Override\r
+ public void processUpdatedNeutronDto(Port original, Port delta) {\r
+ portHandler.processUpdated(original, delta);\r
+ }\r
+\r
+ @Override\r
+ public void processDeletedNeutronDto(Port port) {\r
+ // handled by BaseEndpointByPort removal\r
+ }\r
+\r
+ @Override\r
+ protected void onWrite(DataObjectModification<BaseEndpointByPort> rootNode,\r
+ InstanceIdentifier<BaseEndpointByPort> rootIdentifier) {\r
+ if (rootNode.getDataBefore() == null) {\r
+ portHandler.processCreated(rootNode.getDataAfter());\r
+ }\r
+ }\r
+\r
+ @Override\r
+ protected void onDelete(DataObjectModification<BaseEndpointByPort> rootNode,\r
+ InstanceIdentifier<BaseEndpointByPort> rootIdentifier) {\r
+ portHandler.processDeleted(rootNode.getDataBefore());\r
+ }\r
+\r
+ @Override\r
+ protected void onSubtreeModified(DataObjectModification<BaseEndpointByPort> rootNode,\r
+ InstanceIdentifier<BaseEndpointByPort> rootIdentifier) {\r
+ // update should not happen\r
+ }\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
+package org.opendaylight.groupbasedpolicy.neutron.vpp.mapper.processors;\r
+\r
+import org.opendaylight.yangtools.yang.binding.DataObject;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
+\r
+interface MappingProvider<T extends DataObject> {\r
+\r
+ InstanceIdentifier<T> getNeutronDtoIid();\r
+\r
+ void processCreatedNeutronDto(T t);\r
+\r
+ void processUpdatedNeutronDto(T original, T delta);\r
+\r
+ void processDeletedNeutronDto(T t);\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
+package org.opendaylight.groupbasedpolicy.neutron.vpp.mapper.processors;\r
+\r
+import java.io.Closeable;\r
+import java.util.ArrayList;\r
+import java.util.Collection;\r
+import java.util.LinkedHashSet;\r
+import java.util.List;\r
+import java.util.Set;\r
+import java.util.concurrent.ExecutionException;\r
+\r
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;\r
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;\r
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
+import org.opendaylight.groupbasedpolicy.neutron.vpp.mapper.SocketInfo;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;\r
+import org.opendaylight.yangtools.concepts.ListenerRegistration;\r
+import org.opendaylight.yangtools.yang.binding.DataObject;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;\r
+import org.slf4j.Logger;\r
+import org.slf4j.LoggerFactory;\r
+\r
+import com.google.common.annotations.VisibleForTesting;\r
+import com.google.common.collect.Iterators;\r
+import com.google.common.collect.PeekingIterator;\r
+\r
+public class NeutronListener implements DataTreeChangeListener<Neutron>, Closeable {\r
+\r
+ private static final Logger LOG = LoggerFactory.getLogger(NeutronListener.class);\r
+\r
+ private final Set<MappingProvider<? extends DataObject>> dataChangeProviders = new LinkedHashSet<>();\r
+ protected ListenerRegistration<NeutronListener> registeredListener;\r
+\r
+ public NeutronListener(DataBroker dataBroker, SocketInfo socketInfo) {\r
+ registerHandlersAndListeners(dataBroker, socketInfo);\r
+ registeredListener = dataBroker.registerDataTreeChangeListener(new DataTreeIdentifier<>(\r
+ LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.builder(Neutron.class).build()), this);\r
+ }\r
+\r
+ private void registerHandlersAndListeners(DataBroker dataBroker, SocketInfo socketInfo) {\r
+ PortHandler portHandler = new PortHandler(dataBroker, socketInfo);\r
+ dataChangeProviders.add(new BaseEndpointByPortListener(portHandler, dataBroker));\r
+ }\r
+\r
+ @Override\r
+ public void onDataTreeChanged(Collection<DataTreeModification<Neutron>> changes) {\r
+ for (DataTreeModification<Neutron> change : changes) {\r
+ DataObjectModification<Neutron> rootNode = change.getRootNode();\r
+ for (MappingProvider<? extends DataObject> provider : dataChangeProviders) {\r
+ for (DataObjectModification<? extends DataObject> modDto : findModifiedData(provider, rootNode)) {\r
+ try {\r
+ processChangedData(modDto, modDto.getModificationType(), provider);\r
+ } catch (InterruptedException | ExecutionException e) {\r
+ LOG.error("Failed to process {} modification of node: {}. {}", modDto.getModificationType(),\r
+ modDto.getIdentifier(), e.getStackTrace());\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ List<DataObjectModification<? extends DataObject>> findModifiedData(MappingProvider<? extends DataObject> provider,\r
+ DataObjectModification<Neutron> rootNode) {\r
+ List<DataObjectModification<? extends DataObject>> modDtos = new ArrayList<>();\r
+ PeekingIterator<PathArgument> pathArgs = Iterators.peekingIterator(provider.getNeutronDtoIid()\r
+ .getPathArguments()\r
+ .iterator());\r
+ DataObjectModification<? extends DataObject> modifDto = rootNode;\r
+ while (pathArgs.hasNext()) {\r
+ pathArgs.next();\r
+ for (DataObjectModification<? extends DataObject> childDto : modifDto.getModifiedChildren()) {\r
+ if (pathArgs.hasNext() && childDto.getDataType().equals(pathArgs.peek().getType())) {\r
+ if (childDto.getDataType().equals(provider.getNeutronDtoIid().getTargetType())) {\r
+ modDtos.add(childDto);\r
+ } else {\r
+ modifDto = childDto;\r
+ break;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ return modDtos;\r
+ }\r
+\r
+ @SuppressWarnings("unchecked")\r
+ <T extends DataObject> void processChangedData(DataObjectModification<?> dto, ModificationType m,\r
+ MappingProvider<T> processor) throws InterruptedException, ExecutionException {\r
+ switch (m) {\r
+ case WRITE: {\r
+ if (dto.getDataBefore() != null) {\r
+ processor.processUpdatedNeutronDto((T) dto.getDataBefore(), (T) dto.getDataAfter());\r
+ } else {\r
+ processor.processCreatedNeutronDto((T) dto.getDataAfter());\r
+ }\r
+ break;\r
+ }\r
+ case SUBTREE_MODIFIED: {\r
+ processor.processUpdatedNeutronDto((T) dto.getDataBefore(), (T) dto.getDataAfter());\r
+ break;\r
+ }\r
+ case DELETE: {\r
+ processor.processDeletedNeutronDto((T) dto.getDataBefore());\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+ @VisibleForTesting\r
+ void clearDataChangeProviders() {\r
+ dataChangeProviders.clear();\r
+ }\r
+\r
+ @VisibleForTesting\r
+ <T extends DataObject> void addDataChangeProvider(MappingProvider<T> t) {\r
+ dataChangeProviders.add(t);\r
+ }\r
+\r
+ @Override\r
+ public void close() {\r
+ registeredListener.close();\r
+ }\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
+package org.opendaylight.groupbasedpolicy.neutron.vpp.mapper.processors;\r
+\r
+import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;\r
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;\r
+import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;\r
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;\r
+import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction;\r
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
+import org.opendaylight.controller.md.sal.common.api.data.TransactionChain;\r
+import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener;\r
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;\r
+import org.opendaylight.groupbasedpolicy.neutron.vpp.mapper.SocketInfo;\r
+import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;\r
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.UniqueId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.Mappings;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.GbpByNeutronMappings;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.BaseEndpointsByPorts;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.base.endpoints.by.ports.BaseEndpointByPort;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.base.endpoints.by.ports.BaseEndpointByPortKey;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.Config;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpointBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpointKey;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.vpp.endpoint._interface.type.choice.VhostUserCaseBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.binding.rev150712.PortBindingExtension;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.PortKey;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;\r
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;\r
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;\r
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;\r
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;\r
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;\r
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;\r
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;\r
+import org.slf4j.Logger;\r
+import org.slf4j.LoggerFactory;\r
+\r
+import com.google.common.annotations.VisibleForTesting;\r
+import com.google.common.base.Optional;\r
+\r
+public class PortHandler implements TransactionChainListener {\r
+\r
+ private static final Logger LOG = LoggerFactory.getLogger(MappingProvider.class);\r
+\r
+ private static final String COMPUTE_OWNER = "compute";\r
+ private static final String VHOST_USER = "vhostuser";\r
+ private static final String NETCONF_TOPOLOGY_ID = "topology-netconf";\r
+\r
+ private BindingTransactionChain transactionChain;\r
+ BaseEndpointByPortListener portByBaseEpListener;\r
+ DataBroker dataBroker;\r
+ SocketInfo socketInfo;\r
+\r
+ PortHandler(DataBroker dataBroker, SocketInfo socketInfo) {\r
+ this.dataBroker = dataBroker;\r
+ this.socketInfo = socketInfo;\r
+ transactionChain = this.dataBroker.createTransactionChain(this);\r
+ }\r
+\r
+ void processCreated(Port port) {\r
+ ReadTransaction rTx = dataBroker.newReadOnlyTransaction();\r
+ Optional<BaseEndpointByPort> optBaseEpByPort = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,\r
+ createBaseEpByPortIid(port.getUuid()), rTx);\r
+ if (!optBaseEpByPort.isPresent()) {\r
+ return;\r
+ }\r
+ processCreatedData(port, optBaseEpByPort.get());\r
+ }\r
+\r
+ void processCreated(BaseEndpointByPort bebp) {\r
+ ReadTransaction rTx = dataBroker.newReadOnlyTransaction();\r
+ Optional<Port> optPort = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,\r
+ createPortIid(bebp.getPortId()), rTx);\r
+ if (!optPort.isPresent()) {\r
+ return;\r
+ }\r
+ processCreatedData(optPort.get(), bebp);\r
+ }\r
+\r
+ @VisibleForTesting\r
+ void processCreatedData(Port port, BaseEndpointByPort bebp) {\r
+ if (isValidVhostUser(port)) {\r
+ VppEndpoint vppEp = buildVhostUserEndpoint(port, bebp);\r
+ writeVppEndpoint(createVppEndpointIid(vppEp.getKey()), vppEp);\r
+ LOG.debug("Created vpp-endpoint {}", vppEp);\r
+ }\r
+ }\r
+\r
+ private boolean isValidVhostUser(Port port) {\r
+ PortBindingExtension portBindingExt = port.getAugmentation(PortBindingExtension.class);\r
+ if (portBindingExt != null) {\r
+ String vifType = portBindingExt.getVifType();\r
+ String deviceOwner = port.getDeviceOwner();\r
+ if (vifType != null && deviceOwner != null) {\r
+ if (vifType.contains(VHOST_USER) && deviceOwner.contains(COMPUTE_OWNER)) {\r
+ return true;\r
+ }\r
+ }\r
+ }\r
+ return false;\r
+ }\r
+\r
+ void processUpdated(Port original, Port delta) {\r
+ if (isValidVhostUser(original)) {\r
+ ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();\r
+ Optional<BaseEndpointByPort> optBebp = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,\r
+ createBaseEpByPortIid(original.getUuid()), rTx);\r
+ rTx.close();\r
+ if (!optBebp.isPresent()) {\r
+ return;\r
+ }\r
+ processDeleted(optBebp.get());\r
+ }\r
+ processCreated(delta);\r
+ }\r
+\r
+ void processDeleted(BaseEndpointByPort bebp) {\r
+ VppEndpointKey vppEpKey = new VppEndpointKey(bebp.getAddress(), bebp.getAddressType(), bebp.getContextId(),\r
+ bebp.getContextType());\r
+ InstanceIdentifier<VppEndpoint> vppEpIid = createVppEndpointIid(vppEpKey);\r
+ ReadOnlyTransaction rTx = transactionChain.newReadOnlyTransaction();\r
+ Optional<VppEndpoint> readVppEp = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, vppEpIid, rTx);\r
+ rTx.close();\r
+ if (readVppEp.isPresent()) {\r
+ writeVppEndpoint(vppEpIid, null);\r
+ LOG.debug("Deleted vpp-endpoint {}", vppEpKey);\r
+ }\r
+ }\r
+\r
+ private void writeVppEndpoint(InstanceIdentifier<VppEndpoint> vppEpIid, VppEndpoint vppEp) {\r
+ WriteTransaction wTx = transactionChain.newWriteOnlyTransaction();\r
+ if (vppEp != null) {\r
+ wTx.put(LogicalDatastoreType.CONFIGURATION, vppEpIid, vppEp, true);\r
+ } else {\r
+ wTx.delete(LogicalDatastoreType.CONFIGURATION, vppEpIid);\r
+ }\r
+ try {\r
+ wTx.submit().checkedGet();\r
+ } catch (TransactionCommitFailedException e) {\r
+ LOG.error("Transaction chain commit failed. {}", e);\r
+ transactionChain.close();\r
+ transactionChain = dataBroker.createTransactionChain(this);\r
+ }\r
+ }\r
+\r
+ @VisibleForTesting\r
+ VppEndpoint buildVhostUserEndpoint(Port port, BaseEndpointByPort bebp) {\r
+ PortBindingExtension portBinding = port.getAugmentation(PortBindingExtension.class);\r
+ String socket = socketInfo.getSocketPath() + socketInfo.getSocketPrefix() + bebp.getPortId().getValue();\r
+ return new VppEndpointBuilder().setDescription("neutron port")\r
+ .setContextId(bebp.getContextId())\r
+ .setContextType(bebp.getContextType())\r
+ .setAddress(bebp.getAddress())\r
+ .setInterfaceTypeChoice(new VhostUserCaseBuilder().setSocket(socket).build())\r
+ .setAddressType(bebp.getAddressType())\r
+ .setVppInterfaceName(bebp.getPortId().getValue())\r
+ .setVppNodePath(createNodeIid(new NodeId(portBinding.getHostId())))\r
+ .build();\r
+ }\r
+\r
+ private InstanceIdentifier<Node> createNodeIid(NodeId nodeId) {\r
+ return InstanceIdentifier.builder(NetworkTopology.class)\r
+ .child(Topology.class, new TopologyKey(new TopologyId(NETCONF_TOPOLOGY_ID)))\r
+ .child(Node.class, new NodeKey(nodeId))\r
+ .build();\r
+ }\r
+\r
+ private InstanceIdentifier<VppEndpoint> createVppEndpointIid(VppEndpointKey vppEpKey) {\r
+ return InstanceIdentifier.builder(Config.class).child(VppEndpoint.class, vppEpKey).build();\r
+ }\r
+\r
+ private InstanceIdentifier<BaseEndpointByPort> createBaseEpByPortIid(Uuid uuid) {\r
+ return createBaseEpByPortIid(new UniqueId(uuid.getValue()));\r
+ }\r
+\r
+ private InstanceIdentifier<BaseEndpointByPort> createBaseEpByPortIid(UniqueId uuid) {\r
+ return InstanceIdentifier.builder(Mappings.class)\r
+ .child(GbpByNeutronMappings.class)\r
+ .child(BaseEndpointsByPorts.class)\r
+ .child(BaseEndpointByPort.class, new BaseEndpointByPortKey(uuid))\r
+ .build();\r
+ }\r
+\r
+ InstanceIdentifier<Port> createWildcartedPortIid() {\r
+ return portsIid().child(Port.class).build();\r
+ }\r
+\r
+ private InstanceIdentifier<Port> createPortIid(UniqueId uuid) {\r
+ return portsIid().child(Port.class, new PortKey(new Uuid(uuid.getValue()))).build();\r
+ }\r
+\r
+ private InstanceIdentifierBuilder<Ports> portsIid() {\r
+ return InstanceIdentifier.builder(Neutron.class).child(Ports.class);\r
+ }\r
+\r
+ @Override\r
+ public void onTransactionChainFailed(TransactionChain<?, ?> chain, AsyncTransaction<?, ?> transaction,\r
+ Throwable cause) {\r
+ LOG.error("Transaction chain failed. {}", cause.getMessage());\r
+ transactionChain.close();\r
+ transactionChain = dataBroker.createTransactionChain(this);\r
+ }\r
+\r
+ @Override\r
+ public void onTransactionChainSuccessful(TransactionChain<?, ?> chain) {\r
+ LOG.trace("Transaction chain was successfull. {}", chain);\r
+ }\r
+}\r
--- /dev/null
+/*
+ * Copyright (c) 2016 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
+ */
+
+module neutron-vpp-mapper-impl {
+
+ yang-version 1;
+ namespace "urn:opendaylight:params:xml:ns:yang:controller:config:neutron-vpp-mapper:impl";
+ prefix "neutron-vpp-mapper-impl";
+
+ import config { prefix config; revision-date 2013-04-05; }
+ import opendaylight-md-sal-binding { prefix mdsal; revision-date 2013-10-28; }
+
+ description
+ "This module contains the base YANG definitions for
+ neutron-vpp-mapper implementation.";
+
+ revision "2016-04-25" {
+ description
+ "Initial revision.";
+ }
+
+ // This is the definition of the service implementation as a module identity.
+ identity neutron-vpp-mapper-impl {
+ base config:module-type;
+
+ // Specifies the prefix for generated java classes.
+ config:java-name-prefix NeutronVppMapper;
+ }
+
+ // Augments the 'configuration' choice node under modules/module.
+ augment "/config:modules/config:module/config:configuration" {
+ case neutron-vpp-mapper-impl {
+ when "/config:modules/config:module/config:type = 'neutron-vpp-mapper-impl'";
+
+ container data-broker {
+ uses config:service-ref {
+ refine type {
+ mandatory true;
+ config:required-identity mdsal:binding-async-data-broker;
+ }
+ }
+ }
+
+ container rpc-registry {
+ uses config:service-ref {
+ refine type {
+ mandatory true;
+ config:required-identity mdsal:binding-rpc-registry;
+ }
+ }
+ }
+
+ leaf vhostSocketPath {
+ description "Base system directory path for the vhost user host socket filehandle";
+ type string;
+ default "/tmp/";
+ }
+
+ leaf vhostSocketPrefix {
+ description "Prefix for the vhost user host socket filehandle";
+ type string;
+ default "socket_";
+ }
+ }
+ }
+}
\ No newline at end of file
--- /dev/null
+/*\r
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
+package org.opendaylight.groupbasedpolicy.neutron.vpp.mapper.processors;\r
+\r
+import static org.mockito.Matchers.any;\r
+import static org.mockito.Matchers.eq;\r
+import static org.mockito.Mockito.verify;\r
+\r
+import java.util.concurrent.ExecutionException;\r
+\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.mockito.Mockito;\r
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;\r
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;\r
+import org.opendaylight.controller.md.sal.binding.test.AbstractDataBrokerTest;\r
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
+import org.opendaylight.groupbasedpolicy.neutron.vpp.mapper.SocketInfo;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.Mappings;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.GbpByNeutronMappings;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.BaseEndpointsByPorts;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.base.endpoints.by.ports.BaseEndpointByPort;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.PortBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
+\r
+public class NeutronListenerTest extends AbstractDataBrokerTest {\r
+\r
+ private DataBroker dataBroker;\r
+\r
+ private SocketInfo socketInfo;\r
+ private Port port;\r
+ private BaseEndpointByPort bebp;\r
+ private NeutronListener neutronListener;\r
+ private BaseEndpointByPortListener baseEpByPortListener;\r
+\r
+ @Before\r
+ public void init() {\r
+ port = TestUtils.createValidVppPort();\r
+ bebp = TestUtils.createBaseEndpointByPortForPort();\r
+ socketInfo = new SocketInfo("/tmp/", "_socket");\r
+ dataBroker = getDataBroker();\r
+ neutronListener = new NeutronListener(dataBroker, socketInfo);\r
+ neutronListener.clearDataChangeProviders();\r
+ baseEpByPortListener = Mockito.spy(new BaseEndpointByPortListener(new PortHandler(\r
+ dataBroker, socketInfo), dataBroker));\r
+ neutronListener.addDataChangeProvider(baseEpByPortListener);\r
+ }\r
+\r
+ @Test\r
+ public void constructorTest() {\r
+ dataBroker = Mockito.spy(dataBroker);\r
+ NeutronListener neutronListener = new NeutronListener(dataBroker, socketInfo);\r
+ verify(dataBroker).registerDataTreeChangeListener(\r
+ eq(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,\r
+ InstanceIdentifier.builder(Neutron.class)\r
+ .build())), any(NeutronListener.class));\r
+ verify(dataBroker).registerDataTreeChangeListener(\r
+ eq(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,\r
+ InstanceIdentifier.builder(Mappings.class)\r
+ .child(GbpByNeutronMappings.class)\r
+ .child(BaseEndpointsByPorts.class)\r
+ .child(BaseEndpointByPort.class)\r
+ .build())), any(BaseEndpointByPortListener.class));\r
+ neutronListener.close();\r
+ }\r
+\r
+ @Test\r
+ public void testProcessCreatedNeutronDto() throws Exception {\r
+ putPortAndBaseEndpointByPort();\r
+ neutronListener.close();\r
+ verify(baseEpByPortListener).processCreatedNeutronDto(port);\r
+ }\r
+\r
+ @Test\r
+ public void testProcessUpdatedNeutronDto() throws Exception {\r
+ putPortAndBaseEndpointByPort();\r
+ Port updatedPort = new PortBuilder(port).setName("renamed").build();\r
+ WriteTransaction wTx = dataBroker.newWriteOnlyTransaction();\r
+ wTx.put(LogicalDatastoreType.CONFIGURATION, TestUtils.createPortIid(updatedPort.getKey()), updatedPort);\r
+ wTx.submit().get();\r
+ neutronListener.close();\r
+ verify(baseEpByPortListener).processUpdatedNeutronDto(port, updatedPort);\r
+ }\r
+\r
+ @Test\r
+ public void testProcessDeletedNeutronDto() throws Exception {\r
+ putPortAndBaseEndpointByPort();\r
+ WriteTransaction wTx = dataBroker.newWriteOnlyTransaction();\r
+ wTx.delete(LogicalDatastoreType.CONFIGURATION, TestUtils.createPortIid(port.getKey()));\r
+ wTx.submit().get();\r
+ verify(baseEpByPortListener).processDeletedNeutronDto(port);\r
+ }\r
+\r
+ private void putPortAndBaseEndpointByPort() throws InterruptedException, ExecutionException {\r
+ WriteTransaction wTx = dataBroker.newWriteOnlyTransaction();\r
+ wTx.put(LogicalDatastoreType.CONFIGURATION, TestUtils.createPortIid(port.getKey()), port);\r
+ wTx.put(LogicalDatastoreType.OPERATIONAL, TestUtils.createBaseEpByPortIid(port.getUuid()), bebp);\r
+ wTx.submit().get();\r
+ }\r
+}\r
--- /dev/null
+/*
+ * Copyright (c) 2016 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.groupbasedpolicy.neutron.vpp.mapper.processors;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertNotNull;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.mockito.Mockito;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+import org.opendaylight.controller.md.sal.binding.api.ReadTransaction;
+import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.binding.test.AbstractDataBrokerTest;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.groupbasedpolicy.neutron.vpp.mapper.SocketInfo;
+import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.base.endpoints.by.ports.BaseEndpointByPort;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.vpp.endpoint._interface.type.choice.VhostUserCase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import com.google.common.base.Optional;
+
+public class PortHandlerTest extends AbstractDataBrokerTest {
+
+ private DataBroker dataBroker;
+ private PortHandler portHandler;
+ private BindingTransactionChain transactionChain;
+
+ private Port port;
+ private SocketInfo socketInfo;
+ private BaseEndpointByPort bebp;
+
+ @Rule
+ public ExpectedException thrown = ExpectedException.none();
+
+ @Before
+ public void init() {
+ port = TestUtils.createValidVppPort();
+ bebp = TestUtils.createBaseEndpointByPortForPort();
+ socketInfo = new SocketInfo("/tmp/", "_socket");
+ dataBroker = Mockito.spy(getDataBroker());
+ transactionChain = mock(BindingTransactionChain.class);
+ when(dataBroker.createTransactionChain(any(PortHandler.class))).thenReturn(transactionChain);
+ portHandler = new PortHandler(dataBroker, socketInfo);
+ when(transactionChain.newReadOnlyTransaction()).thenAnswer(new Answer<ReadTransaction>() {
+
+ @Override
+ public ReadTransaction answer(InvocationOnMock invocation) throws Throwable {
+ return dataBroker.newReadOnlyTransaction();
+ }
+ });
+ when(transactionChain.newWriteOnlyTransaction()).thenAnswer(new Answer<WriteTransaction>() {
+
+ @Override
+ public WriteTransaction answer(InvocationOnMock invocation) throws Throwable {
+ return dataBroker.newWriteOnlyTransaction();
+ }
+ });
+ }
+
+ @Test
+ public void testBuildVhostUserEndpoint() {
+ VppEndpoint vppEp = portHandler.buildVhostUserEndpoint(port, bebp);
+ assertEquals(vppEp.getAddress(), bebp.getAddress());
+ assertEquals(vppEp.getAddressType(), bebp.getAddressType());
+ assertEquals(vppEp.getContextId(), bebp.getContextId());
+ assertEquals(vppEp.getContextType(), bebp.getContextType());
+ assertTrue(vppEp.getInterfaceTypeChoice() instanceof VhostUserCase);
+ VhostUserCase vhostUserCase = (VhostUserCase) vppEp.getInterfaceTypeChoice();
+ assertNotNull(vhostUserCase);
+ assertEquals(vhostUserCase.getSocket(), socketInfo.getSocketPath() + socketInfo.getSocketPrefix()
+ + bebp.getPortId().getValue());
+ }
+
+ @Test
+ public void testBuildVhostUserEndpoint_notValidVppEp() {
+ port = TestUtils.createNonVppPort();
+ thrown.expect(NullPointerException.class);
+ portHandler.buildVhostUserEndpoint(port, bebp);
+ }
+
+ @Test
+ public void testCreateWildcartedPortIid() throws TransactionCommitFailedException {
+ InstanceIdentifier<Port> iid = portHandler.createWildcartedPortIid();
+ Class<?>[] expectedTypes = {Neutron.class, Ports.class, Port.class};
+ TestUtils.assertPathArgumentTypes(iid.getPathArguments(), expectedTypes);
+ assertEquals(iid.getTargetType(), Port.class);
+ }
+
+ @Test
+ public void testProcessCreatedData() throws Exception {
+ portHandler.processCreatedData(port, bebp);
+ ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
+ Optional<VppEndpoint> optVppEp = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,
+ TestUtils.createVppEpIid(TestUtils.createVppEndpointKey(bebp)), rTx);
+ assertTrue(optVppEp.isPresent());
+ }
+
+ @Test
+ public void testProcessCreatedData_notValidVppEp() throws Exception {
+ port = TestUtils.createNonVppPort();
+ portHandler.processCreatedData(port, bebp);
+ ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
+ Optional<VppEndpoint> optVppEp = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,
+ TestUtils.createVppEpIid(TestUtils.createVppEndpointKey(bebp)), rTx);
+ assertFalse(optVppEp.isPresent());
+ }
+
+ @Test
+ public void testProcessUpdated() throws Exception {
+ WriteTransaction tx = dataBroker.newWriteOnlyTransaction();
+ putVppEp(port, bebp, tx);
+ putBaseEpByPort(port, bebp, tx);
+ DataStoreHelper.submitToDs(tx);
+ portHandler.processUpdated(port, port);
+ ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
+ Optional<VppEndpoint> optVppEp = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,
+ TestUtils.createVppEpIid(TestUtils.createVppEndpointKey(bebp)), rTx);
+ verify(transactionChain).newReadOnlyTransaction();
+ verify(transactionChain, times(2)).newWriteOnlyTransaction();
+ assertTrue(optVppEp.isPresent());
+ }
+
+ @Test
+ public void testProcessUpdated_notValidVppEpAnymore() throws Exception {
+ Port delta = TestUtils.createNonVppPort();
+ ReadWriteTransaction tx = dataBroker.newReadWriteTransaction();
+ putVppEp(port, bebp, tx);
+ putBaseEpByPort(port, bebp, tx);
+ DataStoreHelper.submitToDs(tx);
+ portHandler.processUpdated(port, delta);
+ ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
+ Optional<VppEndpoint> optVppEp = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,
+ TestUtils.createVppEpIid(TestUtils.createVppEndpointKey(bebp)), rTx);
+ // looks for existing Vpp endpoint
+ verify(transactionChain).newReadOnlyTransaction();
+ // only removes former valid vpp endpoint
+ verify(transactionChain).newWriteOnlyTransaction();
+ assertFalse(optVppEp.isPresent());
+ }
+
+ @Test
+ public void testProcessDeleted() throws Exception {
+ ReadWriteTransaction tx = dataBroker.newReadWriteTransaction();
+ putVppEp(port, bebp, tx);
+ DataStoreHelper.submitToDs(tx);
+ portHandler.processDeleted(bebp);
+ ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
+ Optional<VppEndpoint> optVppEp = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,
+ TestUtils.createVppEpIid(TestUtils.createVppEndpointKey(bebp)), rTx);
+ assertFalse(optVppEp.isPresent());
+ verify(transactionChain).newReadOnlyTransaction();
+ verify(transactionChain).newWriteOnlyTransaction();
+ }
+
+ private void putVppEp(Port port, BaseEndpointByPort bebp, WriteTransaction rwTx) {
+ rwTx.put(LogicalDatastoreType.CONFIGURATION, TestUtils.createVppEpIid(TestUtils.createVppEndpointKey(bebp)),
+ portHandler.buildVhostUserEndpoint(port, bebp));
+ }
+
+ private void putBaseEpByPort(Port port, BaseEndpointByPort bebp, WriteTransaction rwTx) {
+ rwTx.put(LogicalDatastoreType.OPERATIONAL, TestUtils.createBaseEpByPortIid(port.getUuid()), bebp, true);
+ }
+}
--- /dev/null
+/*\r
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
+package org.opendaylight.groupbasedpolicy.neutron.vpp.mapper.processors;\r
+\r
+import static org.junit.Assert.assertEquals;\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.assertTrue;\r
+\r
+import java.util.Iterator;\r
+\r
+import org.opendaylight.groupbasedpolicy.neutron.mapper.util.MappingUtils;\r
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContextId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.UniqueId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.MacAddressType;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.AddressType;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.ContextType;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.Mappings;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.GbpByNeutronMappings;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.BaseEndpointsByPorts;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.base.endpoints.by.ports.BaseEndpointByPort;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.base.endpoints.by.ports.BaseEndpointByPortBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.base.endpoints.by.ports.BaseEndpointByPortKey;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.Config;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpointKey;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.binding.rev150712.PortBindingExtension;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.binding.rev150712.PortBindingExtensionBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.PortBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.PortKey;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;\r
+\r
+public class TestUtils {\r
+\r
+ public static Port createValidVppPort() {\r
+ PortBindingExtension portBindingExt = new PortBindingExtensionBuilder().setHostId("devstack-control")\r
+ .setVifType("vhostuser")\r
+ .build();\r
+ return new PortBuilder().setUuid(new Uuid("00000000-1111-2222-3333-444444444444"))\r
+ .setDeviceOwner("compute")\r
+ .addAugmentation(PortBindingExtension.class, portBindingExt)\r
+ .build();\r
+ }\r
+\r
+ public static Port createNonVppPort() {\r
+ return new PortBuilder().setUuid(new Uuid("00000000-1111-2222-3333-444444444444"))\r
+ .setDeviceOwner("owner1")\r
+ .build();\r
+ }\r
+\r
+ public static BaseEndpointByPort createBaseEndpointByPortForPort() {\r
+ return new BaseEndpointByPortBuilder().setContextId(new ContextId("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"))\r
+ .setAddress("00:11:11:11:11:11")\r
+ .setPortId(new UniqueId("00000000-1111-2222-3333-444444444444"))\r
+ .setContextType(MappingUtils.L2_BRDIGE_DOMAIN)\r
+ .setAddressType(MacAddressType.class)\r
+ .build();\r
+ }\r
+\r
+ public static VppEndpointKey createVppEndpointKey(BaseEndpointByPort bebp) {\r
+ return new VppEndpointKey(bebp.getAddress(), bebp.getAddressType(), bebp.getContextId(), bebp.getContextType());\r
+ }\r
+\r
+ public static InstanceIdentifier<VppEndpoint> createVppEpIid(VppEndpointKey key) {\r
+ return InstanceIdentifier.builder(Config.class).child(VppEndpoint.class, key).build();\r
+ }\r
+\r
+ public static InstanceIdentifier<VppEndpoint> createVppEpIid(String addr, Class<? extends AddressType> addrType,\r
+ ContextId ctxId, Class<? extends ContextType> ctxType) {\r
+ return createVppEpIid(new VppEndpointKey(addr, addrType, ctxId, ctxType));\r
+ }\r
+\r
+ public static InstanceIdentifier<Port> createPortIid(PortKey portKey) {\r
+ return InstanceIdentifier.builder(Neutron.class).child(Ports.class).child(Port.class, portKey).build();\r
+ }\r
+\r
+ public static InstanceIdentifier<BaseEndpointByPort> createBaseEpByPortIid(Uuid uuid) {\r
+ return createBaseEpByPortIid(new UniqueId(uuid.getValue()));\r
+ }\r
+\r
+ public static InstanceIdentifier<BaseEndpointByPort> createBaseEpByPortIid(UniqueId uuid) {\r
+ return InstanceIdentifier.builder(Mappings.class)\r
+ .child(GbpByNeutronMappings.class)\r
+ .child(BaseEndpointsByPorts.class)\r
+ .child(BaseEndpointByPort.class, new BaseEndpointByPortKey(uuid))\r
+ .build();\r
+ }\r
+\r
+ public static void assertPathArgumentTypes(Iterable<PathArgument> pathArguments, Class<?>[] expectedTypes) {\r
+ assertNotNull(pathArguments);\r
+ Iterator<PathArgument> it = pathArguments.iterator();\r
+ for (int i = 0; i < expectedTypes.length; ++i) {\r
+ assertTrue("Next path argument expected.", it.hasNext());\r
+ assertEquals("Unexpected path argument type.", expectedTypes[i], it.next().getType());\r
+ }\r
+ }\r
+}\r
<modules>
<module>artifacts</module>
<module>groupbasedpolicy</module>
+ <module>domain-extensions</module>
<module>renderers</module>
<module>location-providers</module>
<module>neutron-mapper</module>
+ <module>neutron-vpp-mapper</module>
<module>neutron-ovsdb</module>
<module>ui-backend</module>
<module>groupbasedpolicy-ui</module>
/*
* Copyright (c) 2015 Huawei Technologies 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
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledExecutorService;
+import com.google.common.annotations.VisibleForTesting;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
});
}
- private void executeEvent(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
+ @VisibleForTesting
+ void executeEvent(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
// Create
for (DataObject dao : change.getCreatedData().values()) {
if (dao instanceof Contract) {
Map<InstanceIdentifier<?>, DataObject> dao = change.getUpdatedData();
for (Map.Entry<InstanceIdentifier<?>, DataObject> entry : dao.entrySet()) {
if (entry.getValue() instanceof Contract) {
- Contract contract = (Contract) dao;
+ Contract contract = (Contract) entry.getValue();
LOG.debug("Contract {} is Updated.", contract.getId().getValue());
UlnDatastoreApi.submitSecurityGroupsToDs(initSecurityGroupBuilder(contract).build());
}
/*
* Copyright (c) 2015 Huawei Technologies 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
import java.util.UUID;
import java.util.concurrent.ScheduledExecutorService;
+import com.google.common.annotations.VisibleForTesting;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
});
}
- private void executeEvent(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
+ @VisibleForTesting
+ void executeEvent(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
// Create
for (DataObject dao : change.getCreatedData().values()) {
processEndpoint(endpoint);
}
} else if (dao instanceof EndpointL3) {
- LOG.debug("Created EndpointL3 {}", (EndpointL3) dao);
+ LOG.debug("Created EndpointL3 {}", dao);
} else if (dao instanceof EndpointL3Prefix) {
- LOG.warn("Not Handled Event Yet by Faas Renderer. Created EndpointL3Prefix {}", (EndpointL3Prefix) dao);
+ LOG.warn("Not Handled Event Yet by Faas Renderer. Created EndpointL3Prefix {}", dao);
}
}
// Update
Map<InstanceIdentifier<?>, DataObject> dao = change.getUpdatedData();
for (Map.Entry<InstanceIdentifier<?>, DataObject> entry : dao.entrySet()) {
if (entry.getValue() instanceof Endpoint) {
- Endpoint endpoint = (Endpoint) dao;
+ Endpoint endpoint = (Endpoint) entry.getValue();
LOG.debug("Updated Endpoint {}", endpoint);
if (validate(endpoint)) {
policyManager.registerTenant(endpoint.getTenant(), endpoint.getEndpointGroup());
processEndpoint(endpoint);
}
} else if (entry.getValue() instanceof EndpointL3) {
- LOG.debug("Updated EndpointL3 {}", (EndpointL3) dao);
+ LOG.debug("Updated EndpointL3 {}", entry.getValue());
} else if (entry.getValue() instanceof EndpointL3Prefix) {
- LOG.warn("Not Handled Event Yet by Faas Renderer. Updated EndpointL3Prefix {}", (EndpointL3Prefix) dao);
+ LOG.warn("Not Handled Event Yet by Faas Renderer. Updated EndpointL3Prefix {}", entry.getValue());
}
}
// Remove
continue;
}
if (old instanceof Endpoint) {
- Endpoint endpoint = (Endpoint) dao;
+ Endpoint endpoint = (Endpoint) old;
LOG.debug("Removed Endpoint {}", endpoint);
removeFaasEndpointLocationIfExist(endpoint.getTenant(), endpoint.getL2Context(),
endpoint.getMacAddress());
} else if (old instanceof EndpointL3) {
- EndpointL3 endpoint = (EndpointL3) dao;
+ EndpointL3 endpoint = (EndpointL3) old;
LOG.debug("Removed EndpointL3 {}", endpoint);
removeFaasEndpointLocationIfExist(endpoint.getTenant(), endpoint.getL2Context(),
endpoint.getMacAddress());
} else if (old instanceof EndpointL3Prefix) {
- LOG.warn("Not Handled Event Yet by Faas Renderer. Removed EndpointL3Prefix {}", (EndpointL3Prefix) old);
+ LOG.warn("Not Handled Event Yet by Faas Renderer. Removed EndpointL3Prefix {}", old);
}
}
}
}
epLocBuilder.setUuid(epId);
Uuid faasSubnetId = getFaasSubnetId(endpoint);
- List<PrivateIps> privateIpAddresses = new ArrayList<PrivateIps>();
+ List<PrivateIps> privateIpAddresses = new ArrayList<>();
for (L3Address ip : endpoint.getL3Address()) {
PrivateIpsBuilder ipBuilder = new PrivateIpsBuilder();
ipBuilder.setIpAddress(ip.getIpAddress());
/*
* Copyright (c) 2015 Huawei Technologies 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
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledExecutorService;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Optional;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import com.google.common.base.Optional;
-
public class FaasPolicyManager implements DataChangeListener, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(FaasPolicyManager.class);
private final DataBroker dataProvider;
protected final Map<Pair<EndpointGroupId, TenantId>, List<SubnetId>> epgSubnetsMap = new HashMap<>();
private final ConcurrentHashMap<TenantId, Uuid> mappedTenants = new ConcurrentHashMap<>();
- protected final ConcurrentHashMap<TenantId, ArrayList<ListenerRegistration<DataChangeListener>>> registeredTenants = new ConcurrentHashMap<TenantId, ArrayList<ListenerRegistration<DataChangeListener>>>();
+ protected final ConcurrentHashMap<TenantId, ArrayList<ListenerRegistration<DataChangeListener>>> registeredTenants =
+ new ConcurrentHashMap<>();
public FaasPolicyManager(DataBroker dataBroker, ScheduledExecutorService executor) {
this.dataProvider = dataBroker;
/*
* tenant registrations
*/
- ArrayList<ListenerRegistration<DataChangeListener>> list = new ArrayList<ListenerRegistration<DataChangeListener>>();
+ ArrayList<ListenerRegistration<DataChangeListener>> list = new ArrayList<>();
ListenerRegistration<DataChangeListener> reg;
// contracts
reg = dataProvider.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
}
}
- private void registerFollowedEndpointgroup(TenantId gbpTenantId, EndpointGroupId epgId) {
+ @VisibleForTesting
+ void registerFollowedEndpointgroup(TenantId gbpTenantId, EndpointGroupId epgId) {
if (epgId == null) {
return;
}
if (val != null) {
return val;
}
- Uuid faasTenantId = null;
+ Uuid faasTenantId;
if (isUUid(tenantId.getValue())) {
faasTenantId = new Uuid(tenantId.getValue());
} else {
ArrayList<ListenerRegistration<DataChangeListener>> list = registeredTenants.remove(tenantId);
if (list != null) {
for (ListenerRegistration<DataChangeListener> reg : list) {
- reg.close();
+ if (reg != null)
+ reg.close();
}
LOG.debug("Unregistered tenant {}", tenantId);
}
return registeredTenants.containsKey(tenantId);
}
- private boolean handledPolicy(ResolvedPolicy policy) {
+ @VisibleForTesting
+ boolean handledPolicy(ResolvedPolicy policy) {
if (!policy.getConsumerTenantId().equals(policy.getProviderTenantId())) {
// FAAS always assumes consumer and provider EPGs belong to the same tenant
LOG.warn(
policy.getConsumerTenantId().getValue(), policy.getProviderTenantId().getValue());
return false;
}
- if (!isTenantRegistered(policy.getConsumerTenantId())) {
- return false;
- }
- return true;
+ return isTenantRegistered(policy.getConsumerTenantId());
}
private boolean isEqualService(ResolvedPolicy newPolicy, ResolvedPolicy oldPolicy) {
private void registerSubnetWithEpg(EndpointGroupId epgId, TenantId tenantId, SubnetId subnetId, boolean updateLn) {
synchronized (this) {
List<SubnetId> subnets = cloneAndGetEpgSubnets(epgId, tenantId);
- for (SubnetId id : subnets) {
- if (id.equals(subnetId)) {
- return;
- }
+ if(subnets.contains(subnetId)){
+ return;
}
subnets.add(subnetId);
epgSubnetsMap.put(new Pair<>(epgId, tenantId), subnets);
}
}
- private void removeLogicalNetwork(ResolvedPolicy oldPolicy) {
+ @VisibleForTesting
+ void removeLogicalNetwork(ResolvedPolicy oldPolicy) {
if (oldPolicy == null) {
return;
}
return builder;
}
- protected boolean needToCreateLogicalNetwork(ServiceCommunicationLayer comLayer, List<SubnetId> consSubnetIds,
+ @VisibleForTesting
+ boolean needToCreateLogicalNetwork(ServiceCommunicationLayer comLayer, List<SubnetId> consSubnetIds,
List<SubnetId> provSubnetIds, TenantId tenantId, ContractId contractId, EndpointGroup providerEpg,
EndpointGroup consumerEpg, ExternalImplicitGroup externalImplicitGroup) {
Optional<LogicalNetwork> lnOp = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL,
return true;
}
Set<SubnetId> lnProvSubnets = new HashSet<>(logicalNet.getProviderNetwork().getGbpSubnetId());
- if (lnProvSubnets.size() != provSubnetIds.size() || !lnProvSubnets.containsAll(provSubnetIds)) {
- return true;
- }
- return false;
+ return lnProvSubnets.size() != provSubnetIds.size() || !lnProvSubnets.containsAll(
+ provSubnetIds);
}
private ServiceCommunicationLayer findLayerNetwork(TenantId tenantId, List<SubnetId> consSubnetIds,
return null;
}
- protected L3Context readL3ContextInstance(TenantId tenantId, L3ContextId l3cId) {
+ @VisibleForTesting
+ L3Context readL3ContextInstance(TenantId tenantId, L3ContextId l3cId) {
ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction();
InstanceIdentifier<L3Context> iid = IidFactory.l3ContextIid(tenantId, l3cId);
Optional<L3Context> l2Op = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, iid, rTx);
return l2Op.get();
}
- protected L2BridgeDomain readL2BridgeDomainInstance(TenantId tenantId, L2BridgeDomainId l2bId) {
+ @VisibleForTesting
+ L2BridgeDomain readL2BridgeDomainInstance(TenantId tenantId, L2BridgeDomainId l2bId) {
ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction();
InstanceIdentifier<L2BridgeDomain> iid = IidFactory.l2BridgeDomainIid(tenantId, l2bId);
Optional<L2BridgeDomain> l2Op = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, iid, rTx);
return l2Op.get();
}
- protected L2FloodDomain readL2FloodDomain(L2FloodDomainId l2fId, TenantId tenantId) {
+ @VisibleForTesting
+ L2FloodDomain readL2FloodDomain(L2FloodDomainId l2fId, TenantId tenantId) {
ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction();
InstanceIdentifier<L2FloodDomain> iid = IidFactory.l2FloodDomainIid(tenantId, l2fId);
Optional<L2FloodDomain> l2Op = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, iid, rTx);
removeTenantLogicalNetwork(gbpTenantId, faasTenantId, true);
}
- private void removeTenantLogicalNetwork(TenantId gbpTenantId, Uuid faasTenantId, boolean unregister) {
+ @VisibleForTesting
+ void removeTenantLogicalNetwork(TenantId gbpTenantId, Uuid faasTenantId, boolean unregister) {
UlnDatastoreApi.removeTenantFromDsIfExists(faasTenantId);
synchronized (this) {
mappedTenants.remove(gbpTenantId);
/*
* Copyright (c) 2015 Huawei Technologies 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
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledExecutorService;
+import com.google.common.annotations.VisibleForTesting;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
});
}
- private void executeEvent(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
+ @VisibleForTesting
+ void executeEvent(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
// Create
for (DataObject dao : change.getCreatedData().values()) {
if (dao instanceof Subnet) {
Map<InstanceIdentifier<?>, DataObject> dao = change.getUpdatedData();
for (Map.Entry<InstanceIdentifier<?>, DataObject> entry : dao.entrySet()) {
if (entry.getValue() instanceof Subnet) {
- Subnet subnet = (Subnet) dao;
+ Subnet subnet = (Subnet) entry.getValue();
LOG.debug("Subnet {} is Updated.", subnet.getId().getValue());
UlnDatastoreApi.submitSubnetToDs(initSubnetBuilder(subnet).build());
}
/*
* Copyright (c) 2015 Huawei Technologies 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
import java.util.concurrent.ScheduledExecutorService;
+import com.google.common.annotations.VisibleForTesting;
import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.common.rev151013.Uuid;
});
}
- private void executeEvent(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
+ @VisibleForTesting
+ void executeEvent(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
// Remove
for (InstanceIdentifier<?> iid : change.getRemovedPaths()) {
DataObject old = change.getOriginalData().get(iid);
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.faas;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.faas.uln.datastore.api.UlnDatastoreApi;
+import org.opendaylight.groupbasedpolicy.renderer.faas.test.DataChangeListenerTester;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.common.rev151013.Uuid;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.security.rules.rev151013.security.rule.groups.attributes.security.rule.groups.container.SecurityRuleGroups;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.mapped.entity.MappedContract;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.Contract;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.ContractBuilder;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(UlnDatastoreApi.class)
+public class FaasContractManagerListenerCovrgTest {
+
+ private InstanceIdentifier<Contract> contractIid;
+ private ContractId contractId = new ContractId("contractId");
+ private FaasContractManagerListener listener;
+ private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
+ private TenantId gbpTenantId = new TenantId("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
+ private Uuid faasTenantId = new Uuid("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
+ private DataChangeListenerTester tester;
+ private DataBroker dataProvider;
+
+ @SuppressWarnings("unchecked")
+ @Before
+ public void init() {
+ contractIid = mock(InstanceIdentifier.class);
+ dataProvider = mock(DataBroker.class);
+
+ listener = new FaasContractManagerListener(dataProvider, gbpTenantId, faasTenantId, executor);
+ tester = new DataChangeListenerTester(listener);
+ tester.setRemovedPath(contractIid);
+ }
+
+ @Test
+ public void testT() throws ReadFailedException {
+ PowerMockito.mockStatic(UlnDatastoreApi.class);
+ PowerMockito.doNothing().when(UlnDatastoreApi.class);
+ UlnDatastoreApi.submitSecurityGroupsToDs(any(SecurityRuleGroups.class));
+
+ ReadWriteTransaction rwTx = mock(ReadWriteTransaction.class);
+ WriteTransaction woTx = mock(WriteTransaction.class);
+ CheckedFuture<Void, TransactionCommitFailedException> futureVoid = mock(CheckedFuture.class);
+ when(rwTx.submit()).thenReturn(futureVoid);
+ when(woTx.submit()).thenReturn(futureVoid);
+ when(dataProvider.newReadWriteTransaction()).thenReturn(rwTx);
+ when(dataProvider.newWriteOnlyTransaction()).thenReturn(woTx);
+
+ CheckedFuture<Optional<MappedContract>, ReadFailedException> futureMappedContract = mock(CheckedFuture.class);
+ when(rwTx.read(LogicalDatastoreType.OPERATIONAL, FaasIidFactory.mappedContractIid(gbpTenantId, contractId)))
+ .thenReturn(futureMappedContract);
+ Optional<MappedContract> optMappedContract = mock(Optional.class);
+ when(optMappedContract.isPresent()).thenReturn(true);
+ when(futureMappedContract.checkedGet()).thenReturn(optMappedContract);
+
+ Contract contract = new ContractBuilder().setId(contractId).build();
+ tester.setDataObject(contractIid, contract);
+ listener.executeEvent(tester.getChangeMock());
+ }
+
+ private DataObject makeTestContract() {
+ ContractBuilder builder = new ContractBuilder();
+ builder.setId(new ContractId("b4511aac-ae43-11e5-bf7f-feff819cdc9f"));
+ return builder.build();
+ }
+}
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.faas;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.groupbasedpolicy.api.EpRendererAugmentationRegistry;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.faas.endpoint.rev151009.FaasEndpointContextInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.RegisterEndpointInput;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.RegisterL3PrefixEndpointInput;
+
+public class FaasEndpointAugCovrgTest {
+
+ EpRendererAugmentationRegistry epRendererAugmentationRegistry;
+
+ @Before
+ public void init() {
+ epRendererAugmentationRegistry = mock(EpRendererAugmentationRegistry.class);
+ }
+
+ @Test
+ public void testBuildEndpointAugmentation() throws Exception {
+ FaasEndpointAug aug = new FaasEndpointAug(epRendererAugmentationRegistry);
+ RegisterEndpointInput registerEndpointInput = mock(RegisterEndpointInput.class);
+ FaasEndpointContextInput pix = mock(FaasEndpointContextInput.class);
+
+ when(registerEndpointInput.getAugmentation(FaasEndpointContextInput.class)).thenReturn(pix);
+ aug.buildEndpointAugmentation(registerEndpointInput);
+
+ when(registerEndpointInput.getAugmentation(FaasEndpointContextInput.class)).thenReturn(null);
+ aug.buildEndpointAugmentation(registerEndpointInput);
+ aug.close();
+ }
+
+ @Test
+ public void testBuildEndpointL3Augmentation() throws Exception {
+ FaasEndpointAug aug = new FaasEndpointAug(epRendererAugmentationRegistry);
+ RegisterEndpointInput registerEndpointInput = mock(RegisterEndpointInput.class);
+
+ aug.buildEndpointL3Augmentation(registerEndpointInput);
+ aug.close();
+ }
+
+ @Test
+ public void testBuildL3PrefixEndpointAugmentation() throws Exception {
+ FaasEndpointAug aug = new FaasEndpointAug(epRendererAugmentationRegistry);
+ RegisterL3PrefixEndpointInput registerL3PrefixEndpointInput = mock(RegisterL3PrefixEndpointInput.class);
+
+ aug.buildL3PrefixEndpointAugmentation(registerL3PrefixEndpointInput);
+ aug.close();
+ }
+
+}
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.faas;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.groupbasedpolicy.renderer.faas.test.DataChangeListenerTester;
+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.faas.logical.faas.common.rev151013.Uuid;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2BridgeDomainId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubnetId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.Endpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Builder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Prefix;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3PrefixBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.mapped.entity.MappedEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.mapped.entity.MappedEndpointKey;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class FaasEndpointManagerListenerCovrgTest {
+
+ private static final L2BridgeDomainId L_2_BRIDGE_DOMAIN_ID = new L2BridgeDomainId("L2BridgeDomainId");
+ private static final MacAddress MAC_ADDRESS = new MacAddress("00:00:00:00:35:02");
+
+ private InstanceIdentifier<Endpoint> epIid;
+ private FaasEndpointManagerListener listener;
+ private TenantId gbpTenantId = new TenantId("gbpTenantId");
+ private SubnetId subnetId = new SubnetId("subnetId");
+ private Uuid faasTenantId = new Uuid("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
+ private Uuid faasSubnetId = new Uuid("c4511aac-ae43-11e5-bf7f-feff819cdc9f");
+ private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
+ private DataChangeListenerTester tester;
+ private DataBroker dataProvider;
+ private FaasPolicyManager faasPolicyManager;
+
+ @SuppressWarnings("unchecked")
+ @Before
+ public void init() throws ReadFailedException {
+ MappedEndpointKey mappedEndpointKey = new MappedEndpointKey(L_2_BRIDGE_DOMAIN_ID, MAC_ADDRESS);
+
+ dataProvider = mock(DataBroker.class);
+
+ WriteTransaction woTx = mock(WriteTransaction.class);
+ ReadWriteTransaction rwTx = mock(ReadWriteTransaction.class);
+
+ CheckedFuture<Void, TransactionCommitFailedException> futureVoid = mock(CheckedFuture.class);
+ when(woTx.submit()).thenReturn(futureVoid);
+ when(rwTx.submit()).thenReturn(futureVoid);
+ doNothing().when(woTx).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
+ any(DataObject.class));
+
+ CheckedFuture<Optional<MappedEndpoint>, ReadFailedException> futureMappedEndpoint = mock(CheckedFuture.class);
+ Optional<MappedEndpoint> optMappedEndpoint = mock(Optional.class);
+ when(optMappedEndpoint.isPresent()).thenReturn(false);
+ when(futureMappedEndpoint.checkedGet()).thenReturn(optMappedEndpoint);
+ when(rwTx.read(LogicalDatastoreType.OPERATIONAL,
+ FaasIidFactory.mappedEndpointIid(gbpTenantId, mappedEndpointKey))).thenReturn(futureMappedEndpoint);
+
+ when(dataProvider.newWriteOnlyTransaction()).thenReturn(woTx);
+ when(dataProvider.newReadWriteTransaction()).thenReturn(rwTx);
+
+ epIid = mock(InstanceIdentifier.class);
+ faasPolicyManager = spy(new FaasPolicyManager(dataProvider, executor));
+ doNothing().when(faasPolicyManager).removeTenantLogicalNetwork(gbpTenantId, faasTenantId);
+ listener = new FaasEndpointManagerListener(faasPolicyManager, dataProvider, executor);
+ tester = new DataChangeListenerTester(listener);
+ tester.setRemovedPath(epIid);
+ }
+
+ @Test
+ public void testOnDataChanged_Endpoint() {
+ Endpoint ep = new EndpointBuilder().setTenant(gbpTenantId)
+ .setL2Context(L_2_BRIDGE_DOMAIN_ID)
+ .setMacAddress(MAC_ADDRESS)
+ .build();
+ tester.setDataObject(epIid, ep);
+ tester.callOnDataChanged();
+ listener.executeEvent(tester.getChangeMock());
+ }
+
+ @Test
+ public void testOnDataChanged_EndpointL3() {
+ EndpointL3 ep = new EndpointL3Builder().setTenant(gbpTenantId)
+ .setL2Context(L_2_BRIDGE_DOMAIN_ID)
+ .setMacAddress(MAC_ADDRESS)
+ .build();
+ tester.setDataObject(epIid, ep);
+ tester.callOnDataChanged();
+ listener.executeEvent(tester.getChangeMock());
+ }
+
+ @Test
+ public void testOnDataChanged_EndpointL3Prefix() {
+ EndpointL3Prefix ep = new EndpointL3PrefixBuilder().setTenant(gbpTenantId).build();
+ tester.setDataObject(epIid, ep);
+ tester.callOnDataChanged();
+ listener.executeEvent(tester.getChangeMock());
+ }
+
+}
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.faas;\r
+\r
+import static org.junit.Assert.assertNotNull;\r
+\r
+import org.junit.Test;\r
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.MacAddress;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2BridgeDomainId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubnetId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.mapped.entity.MappedEndpointKey;\r
+\r
+public class FaasIidFactoryTest {\r
+\r
+ @Test\r
+ public void testLogicalNetworksIid() {\r
+ assertNotNull(FaasIidFactory.logicalNetworksIid());\r
+ }\r
+\r
+ @Test\r
+ public void testLogicalNetworkIid() {\r
+ EndpointGroupId consumerEpgId = new EndpointGroupId("consumerEpgId");\r
+ TenantId consumerTenantId = new TenantId("consumerTenantId");\r
+ ContractId contractId = new ContractId("contractId");\r
+ EndpointGroupId providerEpgId = new EndpointGroupId("providerEpgId");\r
+ TenantId providerTenantId = new TenantId("providerTenantId");\r
+\r
+ assertNotNull(FaasIidFactory.logicalNetworkIid(consumerEpgId, consumerTenantId, contractId, providerEpgId,\r
+ providerTenantId));\r
+ }\r
+\r
+ @Test\r
+ public void testMappedTenantsEntitiesIid() {\r
+ assertNotNull(FaasIidFactory.mappedTenantsEntitiesIid());\r
+ }\r
+\r
+ @Test\r
+ public void testMappedSubnetIid() {\r
+ TenantId gbpTenantId = new TenantId("gbpTenantId");\r
+ SubnetId subnetId = new SubnetId("subnetId");\r
+\r
+ assertNotNull(FaasIidFactory.mappedSubnetIid(gbpTenantId, subnetId));\r
+ }\r
+\r
+ @Test\r
+ public void testMappedTenantIid() {\r
+ TenantId gbpTenantId = new TenantId("gbpTenantId");\r
+\r
+ assertNotNull(FaasIidFactory.mappedTenantIid(gbpTenantId));\r
+ }\r
+\r
+ @Test\r
+ public void testMappedEntityIid() {\r
+ TenantId gbpTenantId = new TenantId("gbpTenantId");\r
+\r
+ assertNotNull(FaasIidFactory.mappedEntityIid(gbpTenantId));\r
+ }\r
+\r
+ @Test\r
+ public void testMappedContractIid() {\r
+ TenantId gbpTenantId = new TenantId("gbpTenantId");\r
+ ContractId contractId = new ContractId("contractId");\r
+\r
+ assertNotNull(FaasIidFactory.mappedContractIid(gbpTenantId, contractId));\r
+ }\r
+\r
+ @Test\r
+ public void testMappedEndpointIid() {\r
+ TenantId gbpTenantId = new TenantId("gbpTenantId");\r
+ MappedEndpointKey mappedEndpointKey =\r
+ new MappedEndpointKey(new L2BridgeDomainId("L2BridgeDomainId"), new MacAddress("00:00:00:00:35:02"));\r
+\r
+ assertNotNull(FaasIidFactory.mappedEndpointIid(gbpTenantId, mappedEndpointKey));\r
+ }\r
+\r
+}\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.faas;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.faas.uln.datastore.api.UlnDatastoreApi;
+import org.opendaylight.groupbasedpolicy.util.IidFactory;
+import org.opendaylight.groupbasedpolicy.util.TenantUtils;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.common.rev151013.Uuid;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2BridgeDomainId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2FloodDomainId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L3ContextId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubnetId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.LogicalNetworks;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.LogicalNetworksBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.ScopeType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.ServiceCommunicationLayer;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.logical.networks.LogicalNetwork;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.logical.networks.LogicalNetworkBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.logical.networks.logical.network.ConsumerNetworkBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.logical.networks.logical.network.ProviderNetworkBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.MappedEntity;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.MappedTenant;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.Tenant;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L2BridgeDomain;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L2BridgeDomainBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L2FloodDomain;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L2FloodDomainBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L3Context;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L3ContextBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.Subnet;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.SubnetBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.EndpointGroup;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.EndpointGroupBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.ResolvedPolicies;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy.ExternalImplicitGroup;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicyBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.PolicyRuleGroupWithEndpointConstraints;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.PolicyRuleGroupWithEndpointConstraintsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroup;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.resolved.policy.policy.rule.group.with.endpoint.constraints.PolicyRuleGroupBuilder;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({UlnDatastoreApi.class})
+public class FaasPolicyManagerCovrgTest {
+
+ private InstanceIdentifier<DataObject> policyId;
+ private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change;
+ DataBroker dataProvider;
+ private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(Runtime.getRuntime()
+ .availableProcessors());
+ EndpointGroupId consumerEpgId = new EndpointGroupId("consumerEpgId");
+ SubnetId consumerSubnet = new SubnetId("consumerSubnet");
+ SubnetId providerSubnet = new SubnetId("providerSubnet");
+ EndpointGroupId providerEpgId = new EndpointGroupId("providerEpgId");
+ ContractId contractId = new ContractId("contractId");
+ TenantId tenantId = new TenantId("tenantId");
+ Uuid faasTenantId = new Uuid("0eb98cf5-086c-4a81-8a4e-0c3b4566108b");
+ Uuid faasSecRulesId = new Uuid("1eb98cf5-086c-4a81-8a4e-0c3b4566108b");
+ L3ContextId l3Context = new L3ContextId("l3ContextId");
+ EndpointGroupId epgId = new EndpointGroupId("epgId");
+ SubnetId subnetId = new SubnetId("subnetId");
+ Uuid dummyUuid1 = new Uuid("2eb98cf5-086c-4a81-8a4e-0c3b4566108b");
+ Uuid dummyUuid2 = new Uuid("3eb98cf5-086c-4a81-8a4e-0c3b4566108b");
+
+ @SuppressWarnings("unchecked")
+ @Before
+ public void init() throws Exception {
+ policyId = mock(InstanceIdentifier.class);
+ change = mock(AsyncDataChangeEvent.class);
+ policyId = mock(InstanceIdentifier.class);
+ dataProvider = mock(DataBroker.class);
+
+ WriteTransaction writeTransaction = mock(WriteTransaction.class);
+ when(dataProvider.newWriteOnlyTransaction()).thenReturn(writeTransaction);
+ CheckedFuture<Void, TransactionCommitFailedException> futureVoid =
+ mock(CheckedFuture.class);
+ when(writeTransaction.submit()).thenReturn(futureVoid);
+
+ Set<InstanceIdentifier<?>> removedPaths = new HashSet<>();
+ removedPaths.add(policyId);
+ when(change.getRemovedPaths()).thenReturn(removedPaths);
+ }
+
+ @Test
+ public void testConstructor() throws Exception {
+ FaasPolicyManager other = new MockFaasPolicyManager(dataProvider, executor);
+
+ verify(dataProvider).registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.builder(ResolvedPolicies.class)
+ .child(ResolvedPolicy.class)
+ .build(), other, AsyncDataBroker.DataChangeScope.SUBTREE);
+ other.close();
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testRegisterTenant() throws Exception {
+ ReadOnlyTransaction roTx = mock(ReadOnlyTransaction.class);
+ when(dataProvider.newReadOnlyTransaction()).thenReturn(roTx);
+
+ ReadWriteTransaction rwTx = mock(ReadWriteTransaction.class);
+ when(dataProvider.newReadWriteTransaction()).thenReturn(rwTx);
+
+ CheckedFuture<Optional<MappedTenant>, ReadFailedException> futureMappedTenant =
+ mock(CheckedFuture.class);
+ when(roTx.read(LogicalDatastoreType.OPERATIONAL,
+ FaasIidFactory.mappedTenantIid(tenantId))).thenReturn(futureMappedTenant);
+ Optional<MappedTenant> optMappedTenant = mock(Optional.class);
+ when(optMappedTenant.isPresent()).thenReturn(false);
+ when(futureMappedTenant.checkedGet()).thenReturn(optMappedTenant);
+
+ CheckedFuture<Optional<Tenant>, ReadFailedException> futureTenant =
+ mock(CheckedFuture.class);
+ when(roTx.read(LogicalDatastoreType.CONFIGURATION,
+ TenantUtils.tenantIid(tenantId))).thenReturn(futureTenant);
+ Optional<Tenant> optTenant = mock(Optional.class);
+ when(futureTenant.checkedGet()).thenReturn(optTenant);
+
+ CheckedFuture<Optional<MappedEntity>, ReadFailedException> futureMappedEntity =
+ mock(CheckedFuture.class);
+ when(roTx.read(LogicalDatastoreType.OPERATIONAL,
+ FaasIidFactory.mappedEntityIid(tenantId))).thenReturn(futureMappedEntity);
+ Optional<MappedEntity> optMappedEntity = mock(Optional.class);
+ when(futureMappedEntity.checkedGet()).thenReturn(optMappedEntity);
+
+ CheckedFuture<Optional<ResolvedPolicies>, ReadFailedException> futureResolvedPolicies =
+ mock(CheckedFuture.class);
+ when(roTx.read(LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.builder(ResolvedPolicies.class).build())).thenReturn(futureResolvedPolicies);
+ Optional<ResolvedPolicies> optResolvedPolicies = mock(Optional.class);
+ when(optResolvedPolicies.isPresent()).thenReturn(false);
+ when(futureResolvedPolicies.checkedGet()).thenReturn(optResolvedPolicies);
+
+ CheckedFuture<Optional<LogicalNetworks>, ReadFailedException> futureLogicalNetworks =
+ mock(CheckedFuture.class);
+ when(roTx.read(LogicalDatastoreType.OPERATIONAL,
+ FaasIidFactory.logicalNetworksIid())).thenReturn(futureLogicalNetworks);
+ LogicalNetworks logicalNetworks = new LogicalNetworksBuilder()
+ .setLogicalNetwork( new ArrayList<LogicalNetwork>())
+ .build();
+ Optional<LogicalNetworks> optLogicalNetworks = mock(Optional.class);
+ when(optLogicalNetworks.isPresent()).thenReturn(true);
+ when(optLogicalNetworks.get()).thenReturn(logicalNetworks);
+ when(futureLogicalNetworks.checkedGet()).thenReturn(optLogicalNetworks);
+
+ EndpointGroupId epgId = new EndpointGroupId("epgId");
+ FaasPolicyManager policyManager = spy(new FaasPolicyManager(dataProvider, executor));
+ doNothing().when(policyManager).removeTenantLogicalNetwork(tenantId, faasTenantId, false);
+
+ policyManager.registerTenant(tenantId, epgId);
+ }
+
+ @Test
+ public void testRegisterTenant_null(){
+ FaasPolicyManager policyManager = spy(new FaasPolicyManager(dataProvider, executor));
+ doNothing().when(policyManager).registerTenant(tenantId, null);
+
+ policyManager.registerTenant(tenantId);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testRemoveTenantLogicalNetwork() throws ReadFailedException {
+ ReadOnlyTransaction roTx = mock(ReadOnlyTransaction.class);
+ when(dataProvider.newReadOnlyTransaction()).thenReturn(roTx);
+
+ ReadWriteTransaction rwTx = mock(ReadWriteTransaction.class);
+ when(dataProvider.newReadWriteTransaction()).thenReturn(rwTx);
+
+ CheckedFuture<Void, TransactionCommitFailedException> futureVoid = mock(CheckedFuture.class);
+ when(rwTx.submit()).thenReturn(futureVoid);
+
+ CheckedFuture<Optional<LogicalNetworks>, ReadFailedException> futureLogicalNetworks =
+ mock(CheckedFuture.class);
+ when(roTx.read(LogicalDatastoreType.OPERATIONAL,
+ FaasIidFactory.logicalNetworksIid())).thenReturn(futureLogicalNetworks);
+ List<LogicalNetwork> lns = new ArrayList<>();
+ LogicalNetwork ln = new LogicalNetworkBuilder()
+ .setConsumerEpgId(consumerEpgId)
+ .setConsumerTenantId(tenantId)
+ .setContractId(contractId)
+ .setProviderEpgId(providerEpgId)
+ .setProviderTenantId(tenantId)
+ .build();
+ lns.add(ln);
+ LogicalNetworks logicalNetworks = new LogicalNetworksBuilder()
+ .setLogicalNetwork(lns)
+ .build();
+ Optional<LogicalNetworks> optLogicalNetworks = mock(Optional.class);
+ when(optLogicalNetworks.isPresent()).thenReturn(true);
+ when(optLogicalNetworks.get()).thenReturn(logicalNetworks);
+ when(futureLogicalNetworks.checkedGet()).thenReturn(optLogicalNetworks);
+
+ CheckedFuture<Optional<LogicalNetwork>, ReadFailedException> futureLogicalNetwork =
+ mock(CheckedFuture.class);
+ when(rwTx.read(eq(LogicalDatastoreType.OPERATIONAL),
+ eq(FaasIidFactory.logicalNetworkIid(consumerEpgId, tenantId, contractId,
+ providerEpgId, tenantId)))).thenReturn(futureLogicalNetwork);
+ Optional<LogicalNetwork> optionalLogicalNetwork = mock(Optional.class);
+ when(futureLogicalNetwork.checkedGet()).thenReturn(optionalLogicalNetwork);
+
+ CheckedFuture<Optional<MappedEntity>, ReadFailedException> futureMappedEntity =
+ mock(CheckedFuture.class);
+ when(rwTx.read(LogicalDatastoreType.OPERATIONAL,
+ FaasIidFactory.mappedEntityIid(tenantId))).thenReturn(futureMappedEntity);
+ Optional<MappedEntity> optMappedEntity = mock(Optional.class);
+ when(optMappedEntity.isPresent()).thenReturn(true);
+ when(futureMappedEntity.checkedGet()).thenReturn(optMappedEntity);
+
+ CheckedFuture<Optional<MappedTenant>, ReadFailedException> futureMappedTenant =
+ mock(CheckedFuture.class);
+ when(rwTx.read(LogicalDatastoreType.OPERATIONAL,
+ FaasIidFactory.mappedTenantIid(tenantId))).thenReturn(futureMappedTenant);
+ Optional<MappedTenant> optMappedTenant = mock(Optional.class);
+ when(optMappedTenant.isPresent()).thenReturn(true);
+ when(futureMappedTenant.checkedGet()).thenReturn(optMappedTenant);
+
+ PowerMockito.mockStatic(UlnDatastoreApi.class);
+ PowerMockito.doNothing().when(UlnDatastoreApi.class);
+ UlnDatastoreApi.removeTenantFromDsIfExists(any(Uuid.class));
+
+ FaasPolicyManager policyManager = spy(new FaasPolicyManager(dataProvider, executor));
+
+ policyManager.removeTenantLogicalNetwork(tenantId, faasTenantId);
+ }
+
+ @Test
+ public void testUnregisterTenant() throws Exception {
+ FaasPolicyManager policyManager = new FaasPolicyManager(dataProvider, executor);
+
+ policyManager.unregisterTenant(tenantId);
+ }
+
+ @Test
+ public void testIsUuid(){
+ assertFalse(FaasPolicyManager.isUUid(null));
+ assertFalse(FaasPolicyManager.isUUid("non-matching string"));
+ assertTrue(FaasPolicyManager.isUUid("12345678-1234-5123-b123-0123456789ab"));
+ }
+
+ @Test
+ public void testHandledPolicy_notEquals(){
+ FaasPolicyManager policyManager = new FaasPolicyManager(dataProvider, executor);
+ ResolvedPolicy policy = new ResolvedPolicyBuilder()
+ .setConsumerTenantId(new TenantId("t1"))
+ .setProviderTenantId(new TenantId("t2"))
+ .build();
+
+ assertFalse(policyManager.handledPolicy(policy));
+ }
+
+ @Test
+ public void testRegisterFollowedEndpointgroup(){
+ EndpointGroupId epgId = new EndpointGroupId("epgId");
+ FaasPolicyManager policyManager = new FaasPolicyManager(dataProvider, executor);
+
+ policyManager.registerFollowedEndpointgroup(tenantId, null);
+ policyManager.registerFollowedEndpointgroup(tenantId, epgId);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testRegisterSubnetWithEpg() throws ReadFailedException {
+ FaasPolicyManager policyManager = new FaasPolicyManager(dataProvider, executor);
+
+ ReadOnlyTransaction roTx = mock(ReadOnlyTransaction.class);
+ when(dataProvider.newReadOnlyTransaction()).thenReturn(roTx);
+
+ CheckedFuture<Optional<ResolvedPolicies>, ReadFailedException> futureResolvedPolicies =
+ mock(CheckedFuture.class);
+ when(roTx.read(LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.builder(ResolvedPolicies.class).build())).thenReturn(futureResolvedPolicies);
+ Optional<ResolvedPolicies> optResolvedPolicies = mock(Optional.class);
+ when(optResolvedPolicies.isPresent()).thenReturn(false);
+ when(futureResolvedPolicies.checkedGet()).thenReturn(optResolvedPolicies);
+
+
+ policyManager.registerSubnetWithEpg(epgId, tenantId, subnetId);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testReadEndpointGroup() throws ReadFailedException {
+ FaasPolicyManager policyManager = new FaasPolicyManager(dataProvider, executor);
+ ReadOnlyTransaction roTx = mock(ReadOnlyTransaction.class);
+ CheckedFuture<Optional<EndpointGroup>, ReadFailedException> futureEndpointGroup =
+ mock(CheckedFuture.class);
+ Optional<EndpointGroup> optEndpointGroup = mock(Optional.class);
+ when(optEndpointGroup.isPresent()).thenReturn(true);
+ when(futureEndpointGroup.checkedGet()).thenReturn(optEndpointGroup);
+ when(roTx.read(LogicalDatastoreType.CONFIGURATION,
+ IidFactory.endpointGroupIid(tenantId, epgId))).thenReturn(futureEndpointGroup);
+ doNothing().when(roTx).close();
+ when(dataProvider.newReadOnlyTransaction()).thenReturn(roTx);
+
+ policyManager.readEndpointGroup(epgId, tenantId);
+
+ when(optEndpointGroup.isPresent()).thenReturn(false);
+ policyManager.readEndpointGroup(epgId, tenantId);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testReadSubnet() throws ReadFailedException {
+ FaasPolicyManager policyManager = new FaasPolicyManager(dataProvider, executor);
+ ReadOnlyTransaction roTx = mock(ReadOnlyTransaction.class);
+ CheckedFuture<Optional<Subnet>, ReadFailedException> futureSubnet =
+ mock(CheckedFuture.class);
+ Optional<Subnet> optSubnet = mock(Optional.class);
+ when(optSubnet.isPresent()).thenReturn(true);
+ when(futureSubnet.checkedGet()).thenReturn(optSubnet);
+ when(roTx.read(LogicalDatastoreType.CONFIGURATION, IidFactory.subnetIid(tenantId, subnetId))).thenReturn(futureSubnet);
+ doNothing().when(roTx).close();
+ when(dataProvider.newReadOnlyTransaction()).thenReturn(roTx);
+
+ policyManager.readSubnet(subnetId, tenantId);
+
+ when(optSubnet.isPresent()).thenReturn(false);
+ policyManager.readSubnet(subnetId, tenantId);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testReadL3ContextInstance() throws ReadFailedException {
+ FaasPolicyManager policyManager = new FaasPolicyManager(dataProvider, executor);
+ ReadOnlyTransaction roTx = mock(ReadOnlyTransaction.class);
+ CheckedFuture<Optional<L3Context>, ReadFailedException> futureL3Context =
+ mock(CheckedFuture.class);
+ Optional<L3Context> optL3Context = mock(Optional.class);
+ when(optL3Context.isPresent()).thenReturn(true);
+ when(futureL3Context.checkedGet()).thenReturn(optL3Context);
+
+ L3ContextId l3cId = new L3ContextId("l3cId");
+ when(roTx.read(LogicalDatastoreType.CONFIGURATION, IidFactory.l3ContextIid(tenantId, l3cId))).thenReturn(futureL3Context);
+ doNothing().when(roTx).close();
+ when(dataProvider.newReadOnlyTransaction()).thenReturn(roTx);
+
+ policyManager.readL3ContextInstance(tenantId, l3cId);
+
+ when(optL3Context.isPresent()).thenReturn(false);
+ policyManager.readL3ContextInstance(tenantId, l3cId);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testReadL2BridgeDomainInstance() throws ReadFailedException {
+ FaasPolicyManager policyManager = new FaasPolicyManager(dataProvider, executor);
+ ReadOnlyTransaction roTx = mock(ReadOnlyTransaction.class);
+ CheckedFuture<Optional<L2BridgeDomain>, ReadFailedException> futureL2BridgeDomain =
+ mock(CheckedFuture.class);
+ Optional<L2BridgeDomain> optL2BridgeDomain = mock(Optional.class);
+ when(optL2BridgeDomain.isPresent()).thenReturn(true);
+ when(futureL2BridgeDomain.checkedGet()).thenReturn(optL2BridgeDomain);
+
+ L2BridgeDomainId l2bId = new L2BridgeDomainId("l2bId");
+ when(roTx.read(LogicalDatastoreType.CONFIGURATION, IidFactory.l2BridgeDomainIid(tenantId,
+ l2bId))).thenReturn(futureL2BridgeDomain);
+ doNothing().when(roTx).close();
+ when(dataProvider.newReadOnlyTransaction()).thenReturn(roTx);
+
+ policyManager.readL2BridgeDomainInstance(tenantId, l2bId);
+
+ when(optL2BridgeDomain.isPresent()).thenReturn(false);
+ policyManager.readL2BridgeDomainInstance(tenantId, l2bId);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testReadL2FloodDomain() throws ReadFailedException {
+ FaasPolicyManager policyManager = new FaasPolicyManager(dataProvider, executor);
+ ReadOnlyTransaction roTx = mock(ReadOnlyTransaction.class);
+ CheckedFuture<Optional<L2FloodDomain>, ReadFailedException> futureL2FloodDomain =
+ mock(CheckedFuture.class);
+ Optional<L2FloodDomain> optL2FloodDomain = mock(Optional.class);
+ when(optL2FloodDomain.isPresent()).thenReturn(true);
+ when(futureL2FloodDomain.checkedGet()).thenReturn(optL2FloodDomain);
+
+ L2FloodDomainId l2fId = new L2FloodDomainId("l2fId");
+ when(roTx.read(LogicalDatastoreType.CONFIGURATION, IidFactory.l2FloodDomainIid(tenantId,
+ l2fId))).thenReturn(futureL2FloodDomain);
+ doNothing().when(roTx).close();
+ when(dataProvider.newReadOnlyTransaction()).thenReturn(roTx);
+
+ policyManager.readL2FloodDomain(l2fId, tenantId);
+
+ when(optL2FloodDomain.isPresent()).thenReturn(false);
+ policyManager.readL2FloodDomain(l2fId, tenantId);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testNeedToCreateLogicalNetwork() throws ReadFailedException {
+
+ ServiceCommunicationLayer comLayer = ServiceCommunicationLayer.Layer2;
+ List<SubnetId> consSubnetIds = new ArrayList<>();
+ SubnetId consSubnetId = new SubnetId("consSubnetId");
+ consSubnetIds.add(consSubnetId);
+ List<SubnetId> provSubnetIds = new ArrayList<>();
+ SubnetId provSubnetId = new SubnetId("provSubnetId");
+ provSubnetIds.add(provSubnetId);
+ ContractId contractId = new ContractId("contractId");
+ EndpointGroup providerEpg = new EndpointGroupBuilder()
+ .setId(providerEpgId)
+ .build();
+ EndpointGroup consumerEpg = new EndpointGroupBuilder()
+ .setId(consumerEpgId)
+ .build();
+ ExternalImplicitGroup externalImplicitGroup = ExternalImplicitGroup.ProviderEpg;
+
+ FaasPolicyManager policyManager = new FaasPolicyManager(dataProvider, executor);
+ ReadOnlyTransaction roTx = mock(ReadOnlyTransaction.class);
+ CheckedFuture<Optional<LogicalNetwork>, ReadFailedException> futureLogicalNetwork =
+ mock(CheckedFuture.class);
+ Optional<LogicalNetwork> optLogicalNetwork = mock(Optional.class);
+ when(optLogicalNetwork.isPresent()).thenReturn(true);
+ LogicalNetwork logicalNet =
+ new LogicalNetworkBuilder()
+ .setCommunicationLayer(ServiceCommunicationLayer.Layer2)
+ .setConsumerNetwork(
+ new ConsumerNetworkBuilder().setNetworkScopeType(ScopeType.Private)
+ .setGbpSubnetId(consSubnetIds)
+ .build())
+ .setProviderNetwork(
+ new ProviderNetworkBuilder().setNetworkScopeType(ScopeType.Public)
+ .setGbpSubnetId(provSubnetIds)
+ .build())
+ .build();
+ when(optLogicalNetwork.get()).thenReturn(logicalNet);
+ when(futureLogicalNetwork.checkedGet()).thenReturn(optLogicalNetwork);
+
+ when(roTx.read(LogicalDatastoreType.OPERATIONAL,
+ FaasIidFactory.logicalNetworkIid(consumerEpg.getId(), tenantId, contractId,
+ providerEpg.getId(), tenantId))).thenReturn(futureLogicalNetwork);
+ doNothing().when(roTx).close();
+ when(dataProvider.newReadOnlyTransaction()).thenReturn(roTx);
+
+ policyManager.needToCreateLogicalNetwork(comLayer, consSubnetIds, provSubnetIds, tenantId,
+ contractId, providerEpg, consumerEpg, externalImplicitGroup);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testRemoveLogicalNetwork()
+ throws ReadFailedException, TransactionCommitFailedException {
+ ServiceCommunicationLayer comLayer = ServiceCommunicationLayer.Layer2;
+ List<SubnetId> consSubnetIds = new ArrayList<>();
+ SubnetId consSubnetId = new SubnetId("consSubnetId");
+ consSubnetIds.add(consSubnetId);
+ List<SubnetId> provSubnetIds = new ArrayList<>();
+ SubnetId provSubnetId = new SubnetId("provSubnetId");
+ provSubnetIds.add(provSubnetId);
+ ContractId contractId = new ContractId("contractId");
+ EndpointGroup providerEpg = new EndpointGroupBuilder()
+ .setId(providerEpgId)
+ .build();
+ EndpointGroup consumerEpg = new EndpointGroupBuilder()
+ .setId(consumerEpgId)
+ .build();
+ ExternalImplicitGroup externalImplicitGroup = ExternalImplicitGroup.ProviderEpg;
+
+ PowerMockito.mockStatic(UlnDatastoreApi.class);
+ PowerMockito.doNothing().when(UlnDatastoreApi.class);
+ UlnDatastoreApi.removeLogicalSwitchFromDsIfExists(any(Uuid.class), any(Uuid.class));
+ PowerMockito.doNothing().when(UlnDatastoreApi.class);
+ UlnDatastoreApi.removeLogicalRouterFromDsIfExists(any(Uuid.class), any(Uuid.class));
+
+ FaasPolicyManager policyManager = new FaasPolicyManager(dataProvider, executor);
+ ReadWriteTransaction rwTx = mock(ReadWriteTransaction.class);
+ CheckedFuture<Optional<LogicalNetwork>, ReadFailedException> futureLogicalNetwork =
+ mock(CheckedFuture.class);
+ CheckedFuture<Void, TransactionCommitFailedException> futureVoid =
+ mock(CheckedFuture.class);
+ Optional<LogicalNetwork> optLogicalNetwork = mock(Optional.class);
+ Optional<Void> optVoid = mock(Optional.class);
+ when(optLogicalNetwork.isPresent()).thenReturn(true);
+ LogicalNetwork logicalNet =
+ new LogicalNetworkBuilder().setCommunicationLayer(ServiceCommunicationLayer.Layer2)
+ .setConsumerNetwork(
+ new ConsumerNetworkBuilder().setNetworkScopeType(ScopeType.Private)
+ .setGbpSubnetId(consSubnetIds)
+ .setLogicalRouterId(dummyUuid1)
+ .build())
+ .setProviderNetwork(
+ new ProviderNetworkBuilder().setNetworkScopeType(ScopeType.Public)
+ .setGbpSubnetId(provSubnetIds)
+ .setLogicalRouterId(dummyUuid2).build())
+ .setConsumerTenantId(tenantId)
+ .setProviderTenantId(tenantId)
+ .build();
+ when(optLogicalNetwork.get()).thenReturn(logicalNet);
+ when(futureLogicalNetwork.checkedGet()).thenReturn(optLogicalNetwork);
+ when(futureVoid.checkedGet()).thenReturn(null);
+
+ when(rwTx.read(LogicalDatastoreType.OPERATIONAL,
+ FaasIidFactory.logicalNetworkIid(consumerEpg.getId(), tenantId, contractId,
+ providerEpg.getId(), tenantId))).thenReturn(futureLogicalNetwork);
+ when(rwTx.submit()).thenReturn(futureVoid);
+ when(dataProvider.newReadWriteTransaction()).thenReturn(rwTx);
+
+ List<PolicyRuleGroup> prg = new ArrayList<>();
+ PolicyRuleGroup prgElement = new PolicyRuleGroupBuilder()
+ .setContractId(new ContractId("contractId"))
+ .build();
+ prg.add(prgElement);
+ List<PolicyRuleGroupWithEndpointConstraints> prgwec = new ArrayList<>();
+ PolicyRuleGroupWithEndpointConstraints prgwecElement = new PolicyRuleGroupWithEndpointConstraintsBuilder()
+ .setPolicyRuleGroup(prg)
+ .build();
+ prgwec.add(prgwecElement);
+ ResolvedPolicy oldPolicy = new ResolvedPolicyBuilder()
+ .setConsumerEpgId(consumerEpgId)
+ .setConsumerTenantId(tenantId)
+ .setProviderEpgId(providerEpgId)
+ .setProviderTenantId(tenantId)
+ .setPolicyRuleGroupWithEndpointConstraints(prgwec)
+ .build();
+
+ policyManager.removeLogicalNetwork(oldPolicy);
+
+ }
+
+ @Test
+ public void testRemoveLogicalNetwork_null(){
+ FaasPolicyManager policyManager = new FaasPolicyManager(dataProvider, executor);
+
+ policyManager.removeLogicalNetwork(null);
+ }
+
+ /*@SuppressWarnings("unchecked")
+ @Test
+ public void testCreateLayer3LogicalNetwork() throws ReadFailedException {
+ ReadOnlyTransaction roTx = mock(ReadOnlyTransaction.class);
+
+ CheckedFuture<Optional<ResolvedPolicies>, ReadFailedException> futureResolvedPolicies =
+ mock(CheckedFuture.class);
+ Optional<ResolvedPolicies> optResolvedPolicies = mock(Optional.class);
+ when(futureResolvedPolicies.checkedGet()).thenReturn(optResolvedPolicies);
+ when(roTx.read(LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.builder(ResolvedPolicies.class).build())).thenReturn(
+ futureResolvedPolicies);
+
+ MappedSubnet mappedSubnet = new MappedSubnetBuilder()
+ .setFaasSubnetId(dummyUuid1)
+ .build();
+ CheckedFuture<Optional<MappedSubnet>, ReadFailedException> futureMappedSubnet =
+ mock(CheckedFuture.class);
+ Optional<MappedSubnet> optMappedSubnet = mock(Optional.class);
+ when(optMappedSubnet.isPresent()).thenReturn(true);
+ when(optMappedSubnet.get()).thenReturn(mappedSubnet);
+ when(futureMappedSubnet.checkedGet()).thenReturn(optMappedSubnet);
+ when(roTx.read(LogicalDatastoreType.OPERATIONAL,
+ FaasIidFactory.mappedSubnetIid(tenantId, subnetId))).thenReturn(
+ futureMappedSubnet);
+
+ when(dataProvider.newReadOnlyTransaction()).thenReturn(roTx);
+
+ EndpointGroup consumerEpg = new EndpointGroupBuilder().setId(consumerEpgId).build();
+ EndpointGroup providerEpg = new EndpointGroupBuilder().setId(providerEpgId).build();
+ FaasPolicyManager policyManager = new FaasPolicyManager(dataProvider, executor);
+
+ policyManager.registerSubnetWithEpg(consumerEpgId, tenantId, consumerSubnet);
+ policyManager.registerSubnetWithEpg(providerEpgId, tenantId, providerSubnet);
+ policyManager.createLayer3LogicalNetwork(consumerEpg, contractId, providerEpg, tenantId,
+ ServiceCommunicationLayer.Layer3, ExternalImplicitGroup.ProviderEpg);
+ }*/
+
+
+
+
+
+ private L3Context makeTestL3Context() {
+ L3ContextBuilder builder = new L3ContextBuilder();
+ builder.setId(l3Context);
+ return builder.build();
+ }
+
+ private L2FloodDomain makeTestL2FloodDomain(String id, L2BridgeDomainId brdgId) {
+ L2FloodDomainBuilder builder = new L2FloodDomainBuilder();
+ builder.setId(new L2FloodDomainId(id));
+ builder.setParent(brdgId);
+ return builder.build();
+ }
+
+ private L2BridgeDomain makeTestBridgeDomain(String id) {
+ L2BridgeDomainBuilder builder = new L2BridgeDomainBuilder();
+ builder.setId(new L2BridgeDomainId(id));
+ builder.setParent(l3Context);
+ return builder.build();
+ }
+
+ private EndpointGroup makeTestEndpointGroup(EndpointGroupId epgId) {
+ EndpointGroupBuilder builder = new EndpointGroupBuilder();
+ builder.setId(epgId);
+ return builder.build();
+ }
+
+ private Subnet makeTestSubnet(SubnetId subnetId, L2FloodDomainId l2FloodDomainId) {
+ SubnetBuilder builder = new SubnetBuilder();
+ builder.setId(subnetId);
+ builder.setParent(l2FloodDomainId);
+ return builder.build();
+
+ }
+
+ private DataObject makeTestResolvedPolicy() {
+ ResolvedPolicyBuilder builder = new ResolvedPolicyBuilder();
+ builder.setConsumerEpgId(consumerEpgId);
+ builder.setConsumerTenantId(tenantId);
+ builder.setProviderEpgId(providerEpgId);
+ builder.setProviderTenantId(tenantId);
+ List<PolicyRuleGroupWithEndpointConstraints> pRulesGrpsWEp = new ArrayList<>();
+ PolicyRuleGroupWithEndpointConstraintsBuilder pRulesGrpWEp = new PolicyRuleGroupWithEndpointConstraintsBuilder();
+ List<PolicyRuleGroup> pRulesGrps = new ArrayList<>();
+ PolicyRuleGroupBuilder pRulesGrp = new PolicyRuleGroupBuilder();
+ pRulesGrp.setContractId(contractId);
+ pRulesGrps.add(pRulesGrp.build());
+ pRulesGrpWEp.setPolicyRuleGroup(pRulesGrps);
+ pRulesGrpsWEp.add(pRulesGrpWEp.build());
+ builder.setPolicyRuleGroupWithEndpointConstraints(pRulesGrpsWEp);
+ return builder.build();
+ }
+
+ private DataObject makeTestResolvedPolicyWithImpExternalEpg() {
+ ResolvedPolicyBuilder builder = new ResolvedPolicyBuilder((ResolvedPolicy) makeTestResolvedPolicy());
+ builder.setExternalImplicitGroup(ExternalImplicitGroup.ConsumerEpg);
+ return builder.build();
+ }
+}
/*
* Copyright (c) 2016 Huawei Technologies 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
import com.google.common.util.concurrent.CheckedFuture;
-@PrepareForTest(UlnDatastoreApi.class)
-@RunWith(PowerMockRunner.class)
public class FaasPolicyManagerTest {
private InstanceIdentifier<DataObject> policyId;
change = mock(AsyncDataChangeEvent.class);
policyId = mock(InstanceIdentifier.class);
dataProvider = mock(DataBroker.class);
- PowerMockito.mockStatic(UlnDatastoreApi.class);
WriteTransaction writeTransaction = mock(WriteTransaction.class);
when(dataProvider.newWriteOnlyTransaction()).thenReturn(writeTransaction);
CheckedFuture<Void, TransactionCommitFailedException> checkedFuture = mock(CheckedFuture.class);
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.faas;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import com.google.common.util.concurrent.CheckedFuture;
+import org.junit.Test;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.groupbasedpolicy.api.EpRendererAugmentationRegistry;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class FaasRendererCovrgTest {
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testConstructor() throws Exception {
+ DataBroker dataProvider = mock(DataBroker.class);
+ EpRendererAugmentationRegistry epRendererAugmentationRegistry = mock(EpRendererAugmentationRegistry.class);
+
+ WriteTransaction wTx = mock(WriteTransaction.class);
+ CheckedFuture<Void, TransactionCommitFailedException> futureVoid = mock(CheckedFuture.class);
+ when(wTx.submit()).thenReturn(futureVoid);
+ doNothing().when(wTx).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
+ any(DataObject.class));
+ when(dataProvider.newWriteOnlyTransaction()).thenReturn(wTx);
+
+ FaasRenderer renderer = new FaasRenderer(dataProvider, epRendererAugmentationRegistry);
+ renderer.close();
+ }
+}
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.faas;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.faas.uln.datastore.api.UlnDatastoreApi;
+import org.opendaylight.groupbasedpolicy.renderer.faas.test.DataChangeListenerTester;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpPrefix;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Prefix;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.common.rev151013.Uuid;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubnetId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.mapped.entity.MappedSubnet;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.faas.rev151009.mapped.tenants.entities.mapped.entity.MappedSubnetBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.Subnet;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.SubnetBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.subnet.Gateways;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.subnet.GatewaysBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.subnet.gateways.Prefixes;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.subnet.gateways.PrefixesBuilder;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(UlnDatastoreApi.class)
+public class FaasSubnetManagerListenerCovrgTest {
+
+ private InstanceIdentifier<Subnet> subnetIid;
+ private FaasSubnetManagerListener listener;
+ private TenantId gbpTenantId = new TenantId("gbpTenantId");
+ private SubnetId subnetId = new SubnetId("subnetId");
+ private Uuid faasTenantId = new Uuid("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
+ private Uuid faasSubnetId = new Uuid("c4511aac-ae43-11e5-bf7f-feff819cdc9f");
+ private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
+ private DataChangeListenerTester tester;
+ private DataBroker dataProvider;
+
+ @SuppressWarnings("unchecked")
+ @Before
+ public void init() {
+ dataProvider = mock(DataBroker.class);
+ subnetIid = mock(InstanceIdentifier.class);
+ listener = new FaasSubnetManagerListener(dataProvider, gbpTenantId, faasTenantId, executor);
+ tester = new DataChangeListenerTester(listener);
+ tester.setRemovedPath(subnetIid);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testOnDataChanged() throws ReadFailedException {
+ PowerMockito.mockStatic(UlnDatastoreApi.class);
+ PowerMockito.doNothing().when(UlnDatastoreApi.class);
+ UlnDatastoreApi.submitSubnetToDs(any(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.subnets.rev151013.subnets.container.subnets.Subnet.class));
+ PowerMockito.doNothing().when(UlnDatastoreApi.class);
+ UlnDatastoreApi.removeSubnetFromDsIfExists(any(Uuid.class), any(Uuid.class));
+
+ ReadWriteTransaction rwTx = mock(ReadWriteTransaction.class);
+ WriteTransaction woTx = mock(WriteTransaction.class);
+ CheckedFuture<Void, TransactionCommitFailedException> futureVoid = mock(CheckedFuture.class);
+ when(rwTx.submit()).thenReturn(futureVoid);
+ when(woTx.submit()).thenReturn(futureVoid);
+
+ CheckedFuture<Optional<MappedSubnet>, ReadFailedException> futureMappedSubnet = mock(CheckedFuture.class);
+ Optional<MappedSubnet> optMappedSubnet = mock(Optional.class);
+ when(optMappedSubnet.isPresent()).thenReturn(true);
+ when(futureMappedSubnet.checkedGet()).thenReturn(optMappedSubnet);
+ when(rwTx.read(LogicalDatastoreType.OPERATIONAL, FaasIidFactory.mappedSubnetIid(gbpTenantId, subnetId)))
+ .thenReturn(futureMappedSubnet);
+ doNothing().when(woTx).put(eq(LogicalDatastoreType.OPERATIONAL),
+ eq(FaasIidFactory.mappedSubnetIid(gbpTenantId, subnetId)), any(MappedSubnet.class));
+
+ when(dataProvider.newReadWriteTransaction()).thenReturn(rwTx);
+ when(dataProvider.newWriteOnlyTransaction()).thenReturn(woTx);
+
+ Subnet subnet = new SubnetBuilder().setId(subnetId).build();
+ tester.setDataObject(subnetIid, subnet);
+ tester.callOnDataChanged();
+ listener.executeEvent(tester.getChangeMock());
+ }
+
+ @Test
+ public void testLoadAll() {
+ PowerMockito.mockStatic(UlnDatastoreApi.class);
+ PowerMockito.doNothing().when(UlnDatastoreApi.class);
+ UlnDatastoreApi.submitSubnetToDs(any(
+ org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.subnets.rev151013.subnets.container.subnets.Subnet.class));
+
+ List<Subnet> subnets = new ArrayList<>();
+ List<MappedSubnet> mpSubnets = new ArrayList<>();
+
+ Subnet subnet = new SubnetBuilder().setId(subnetId).build();
+ subnets.add(subnet);
+ MappedSubnet mappedSubnet =
+ new MappedSubnetBuilder().setGbpSubnetId(subnetId).setFaasSubnetId(faasSubnetId).build();
+ mpSubnets.add(mappedSubnet);
+
+ listener.loadAll(subnets, mpSubnets);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Test
+ public void testInitSubnetBuilder() {
+ WriteTransaction wTx = mock(WriteTransaction.class);
+ CheckedFuture<Void, TransactionCommitFailedException> futureVoid = mock(CheckedFuture.class);
+ when(wTx.submit()).thenReturn(futureVoid);
+ doNothing().when(wTx).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
+ any(DataObject.class));
+ when(dataProvider.newWriteOnlyTransaction()).thenReturn(wTx);
+
+ List<Gateways> gatewaysList = new ArrayList<>();
+ List<Prefixes> prefixesList = new ArrayList<>();
+ Prefixes prefixes = new PrefixesBuilder().setPrefix(new IpPrefix(new Ipv4Prefix("10.0.0.0/8"))).build();
+ prefixesList.add(prefixes);
+ Gateways gateways = new GatewaysBuilder().setGateway(new IpAddress(new Ipv4Address("10.0.0.55")))
+ .setPrefixes(prefixesList)
+ .build();
+ gatewaysList.add(gateways);
+
+ Subnet subnet = new SubnetBuilder().setId(subnetId).setGateways(gatewaysList).build();
+ listener.initSubnetBuilder(subnet);
+ }
+
+}
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.faas;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+
+import com.google.common.util.concurrent.CheckedFuture;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.groupbasedpolicy.renderer.faas.test.DataChangeListenerTester;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.faas.logical.faas.common.rev151013.Uuid;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.Tenant;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.TenantBuilder;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class FaasTenantManagerListenerCovrgTest {
+
+ private InstanceIdentifier<Tenant> tenantIid;
+ private FaasPolicyManager faasPolicyManager;
+ private FaasTenantManagerListener listener;
+ private TenantId gbpTenantId = new TenantId("gbpTenantId");
+ private Uuid faasTenantId = new Uuid("b4511aac-ae43-11e5-bf7f-feff819cdc9f");
+ private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
+ private DataChangeListenerTester tester;
+ private DataBroker dataProvider;
+
+ @SuppressWarnings("unchecked")
+ @Before
+ public void init() {
+ dataProvider = mock(DataBroker.class);
+ WriteTransaction wTx = mock(WriteTransaction.class);
+ CheckedFuture<Void, TransactionCommitFailedException> futureVoid = mock(CheckedFuture.class);
+ when(wTx.submit()).thenReturn(futureVoid);
+ doNothing().when(wTx).put(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
+ any(DataObject.class));
+ when(dataProvider.newWriteOnlyTransaction()).thenReturn(wTx);
+
+ tenantIid = mock(InstanceIdentifier.class);
+ faasPolicyManager = spy(new FaasPolicyManager(dataProvider, executor));
+ doNothing().when(faasPolicyManager).removeTenantLogicalNetwork(gbpTenantId, faasTenantId);
+ listener = new FaasTenantManagerListener(faasPolicyManager, gbpTenantId, faasTenantId, executor);
+ tester = new DataChangeListenerTester(listener);
+ tester.setRemovedPath(tenantIid);
+
+ }
+
+ @Test
+ public void testOnDataChanged() {
+ Tenant tenant = new TenantBuilder().setId(gbpTenantId).build();
+ tester.setDataObject(tenantIid, tenant);
+ tester.callOnDataChanged();
+ listener.executeEvent(tester.getChangeMock());
+ }
+
+}
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.faas.test;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
+import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class DataChangeListenerTester {
+
+ private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changeMock;
+ private DataChangeListener listener;
+
+ private Map<InstanceIdentifier<?>, DataObject> testData;
+ private Set<InstanceIdentifier<?>> removedPaths;
+
+ @SuppressWarnings("unchecked")
+ public DataChangeListenerTester(DataChangeListener listener) {
+ changeMock = mock(AsyncDataChangeEvent.class);
+ testData = new HashMap<>();
+ removedPaths = new HashSet<>();
+
+ this.listener = listener;
+
+ when(changeMock.getCreatedData()).thenReturn(testData);
+ when(changeMock.getOriginalData()).thenReturn(testData);
+ when(changeMock.getUpdatedData()).thenReturn(testData);
+ when(changeMock.getRemovedPaths()).thenReturn(removedPaths);
+ }
+
+ public AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> getChangeMock() {
+ return changeMock;
+ }
+
+ public DataChangeListenerTester setDataObject(InstanceIdentifier<? extends DataObject> iid, DataObject dataObject){
+ testData.clear();
+ return addDataObject(iid, dataObject);
+ }
+
+ public DataChangeListenerTester addDataObject(InstanceIdentifier<? extends DataObject> iid, DataObject dataObject){
+ testData.put(iid, dataObject);
+ return this;
+ }
+
+ public DataChangeListenerTester setRemovedPath(InstanceIdentifier<? extends DataObject> iid){
+ removedPaths.clear();
+ return addRemovedPath(iid);
+ }
+
+ public DataChangeListenerTester addRemovedPath(InstanceIdentifier<? extends DataObject> iid){
+ removedPaths.add(iid);
+ return this;
+ }
+
+ public void callOnDataChanged(){
+ listener.onDataChanged(changeMock);
+ }
+
+}
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.manager.NodeManager;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import static org.opendaylight.sfc.provider.SfcProviderDebug.printTraceStart;
-public class IosXeCapableNodeListenerImpl implements DataTreeChangeListener<NetworkTopology>, AutoCloseable {
+public class IosXeCapableNodeListenerImpl implements DataTreeChangeListener<Node>, AutoCloseable {
private static final Logger LOG = LoggerFactory.getLogger(IosXeCapableNodeListenerImpl.class);
private final NodeManager nodeManager;
public IosXeCapableNodeListenerImpl(final DataBroker dataBroker, final NodeManager nodeManager) {
this.nodeManager = Preconditions.checkNotNull(nodeManager);
- final DataTreeIdentifier<NetworkTopology> networkTopologyPath = new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
- InstanceIdentifier.builder(NetworkTopology.class).build());
+ final DataTreeIdentifier<Node> networkTopologyPath = new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class).child(Node.class).build());
listenerRegistration = Preconditions.checkNotNull(dataBroker
.registerDataTreeChangeListener(networkTopologyPath, this));
LOG.info("network-topology listener registered");
}
@Override
- public void onDataTreeChanged(@Nonnull Collection<DataTreeModification<NetworkTopology>> changes) {
+ public void onDataTreeChanged(@Nonnull Collection<DataTreeModification<Node>> changes) {
printTraceStart(LOG);
- for (DataTreeModification<NetworkTopology> modification : changes) {
- DataObjectModification<NetworkTopology> rootNode = modification.getRootNode();
- NetworkTopology dataAfter = rootNode.getDataAfter();
- NetworkTopology dataBefore = rootNode.getDataBefore();
- if (dataAfter != null && dataBefore == null) {
- nodeManager.syncNodes(dataAfter.getTopology(), null);
- }
- else if (dataAfter == null && dataBefore != null) {
- nodeManager.syncNodes(null, dataBefore.getTopology());
- }
- else if (dataAfter != null) {
- nodeManager.syncNodes(dataAfter.getTopology(), dataBefore.getTopology());
- }
+ for (DataTreeModification<Node> modification : changes) {
+ DataObjectModification<Node> rootNode = modification.getRootNode();
+ Node dataAfter = rootNode.getDataAfter();
+ Node dataBefore = rootNode.getDataBefore();
+ nodeManager.syncNodes(dataAfter, dataBefore);
}
}
import org.opendaylight.controller.md.sal.binding.api.MountPointService;
import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.util.NodeWriter;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.RendererName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.nodes.RendererNode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.nodes.RendererNodeBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.nodes.RendererNodeKey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
+import static org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus.ConnectionStatus.Connected;
+import static org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus.ConnectionStatus.Connecting;
+import static org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus.ConnectionStatus.UnableToConnect;
+
public class NodeManager {
+ public static final RendererName iosXeRenderer = new RendererName("ios-xe-renderer");
+ private static final TopologyId TOPOLOGY_ID = new TopologyId("topology-netconf");
private static final Logger LOG = LoggerFactory.getLogger(NodeManager.class);
- private static Map<InstanceIdentifier, DataBroker> netconfNodeCache = new HashMap<>();
+ private static final Map<InstanceIdentifier, DataBroker> netconfNodeCache = new HashMap<>();
private final DataBroker dataBroker;
- private MountPointService mountService;
+ private final MountPointService mountService;
+ private final List<String> requiredCapabilities;
public NodeManager(final DataBroker dataBroker, BindingAwareBroker.ProviderContext session) {
this.dataBroker = Preconditions.checkNotNull(dataBroker);
mountService = Preconditions.checkNotNull(session.getSALService(MountPointService.class));
+ requiredCapabilities = new RequiredCapabilities().initializeRequiredCapabilities();
}
- public static DataBroker getDataBrokerFromCache(InstanceIdentifier iid) {
+ static DataBroker getDataBrokerFromCache(InstanceIdentifier iid) {
return netconfNodeCache.get(iid); // TODO read from DS
}
- public void syncNodes(List<Topology> dataAfter, List<Topology> dataBefore) {
- if (dataAfter != null && !dataAfter.isEmpty()) {
- updateNodes(dataAfter);
+ public void syncNodes(Node dataAfter, Node dataBefore) {
+ // New node
+ if (dataBefore == null && dataAfter != null) {
+ createNode(dataAfter);
+ }
+ // Connected/disconnected node
+ if (dataBefore != null && dataAfter != null) {
+ updateNode(dataAfter);
+ }
+ // Removed node
+ if (dataBefore != null && dataAfter == null) {
+ removeNode(dataBefore);
}
}
- private void updateNodes(List<Topology> data) {
- // WRITE
- NodeWriter nodeWriter = new NodeWriter();
- for (Topology topology : data) {
- if (topology.getNode() == null || topology.getNode().isEmpty()) {
- continue;
+ private void createNode(Node node) {
+ LOG.info("Registering new node {}", node.getNodeId().getValue());
+ NetconfNode netconfNode = getNodeAugmentation(node);
+ if (netconfNode == null) {
+ return;
+ }
+ NetconfNodeConnectionStatus.ConnectionStatus connectionStatus = netconfNode.getConnectionStatus();
+ switch (connectionStatus) {
+ case Connecting: {
+ LOG.info("Connecting device {} ...", node.getNodeId().getValue());
+ break;
}
- topology.getNode().stream().filter(this::isNetconfDevice).forEach(node -> {
- DataBroker mountpoint = getNodeMountPoint(topology.getTopologyId(), node);
- if (mountpoint != null) {
- netconfNodeCache.put(getMountpointIid(topology.getTopologyId(), node), mountpoint);
- RendererNode rendererNode = remap(topology.getTopologyId(), node);
- nodeWriter.write(rendererNode);
- }
- });
+ case Connected: {
+ resolveConnectedNode(node, netconfNode);
+ LOG.info("Node {} is ready, added to available nodes for IOS-XE Renderer", node.getNodeId().getValue());
+ }
+ case UnableToConnect: {
+ LOG.info("Unable to connect device {}", node.getNodeId().getValue());
+ break;
+ }
+ }
+ }
+
+ private void updateNode(Node node) {
+ NetconfNode netconfNode = getNodeAugmentation(node);
+ if (netconfNode == null || netconfNode.getConnectionStatus() == null) {
+ return;
+ }
+ NetconfNodeConnectionStatus.ConnectionStatus afterNodeStatus = netconfNode.getConnectionStatus();
+ if (afterNodeStatus.equals(Connected)) {
+ resolveConnectedNode(node, netconfNode);
+ LOG.info("Node {} is ready, added to available nodes for IOS-XE Renderer", node.getNodeId().getValue());
+ }
+ if (afterNodeStatus.equals(Connecting)) {
+ resolveDisconnectedNode(node);
+ LOG.info("Node {} has been disconnected, removing from available nodes", node.getNodeId().getValue());
+ }
+ if (afterNodeStatus.equals(UnableToConnect)) {
+ resolveDisconnectedNode(node);
+ LOG.info("Unable to connect node {}, removing from available nodes", node.getNodeId().getValue());
+ }
+ }
+
+ private void removeNode(Node node) {
+ resolveDisconnectedNode(node);
+ LOG.info("Node {} has been removed", node.getNodeId().getValue());
+ }
+
+ private void resolveConnectedNode(Node node, NetconfNode netconfNode) {
+ InstanceIdentifier mountPointIid = getMountpointIid(node);
+ // Mountpoint iid == path in renderer-node
+ RendererNode rendererNode = remapNode(mountPointIid);
+ DataBroker mountpoint = getNodeMountPoint(mountPointIid);
+ NodeWriter nodeWriter = new NodeWriter();
+ nodeWriter.cache(rendererNode);
+ if (isCapableNetconfDevice(node, netconfNode)) {
+ return;
}
nodeWriter.commitToDatastore(dataBroker);
+ netconfNodeCache.put(mountPointIid, mountpoint);
}
- private DataBroker getNodeMountPoint(TopologyId topologyId, Node node) {
- NetconfNode netconfNode = node.getAugmentation(NetconfNode.class);
- if (netconfNode == null) {
- return null;
+ private void resolveDisconnectedNode(Node node) {
+ InstanceIdentifier mountPointIid = getMountpointIid(node);
+ RendererNode rendererNode = remapNode(mountPointIid);
+ NodeWriter nodeWriter = new NodeWriter();
+ nodeWriter.cache(rendererNode);
+ nodeWriter.removeFromDatastore(dataBroker);
+ netconfNodeCache.remove(mountPointIid);
+ }
+
+ private RendererNode remapNode(InstanceIdentifier path) {
+ RendererNodeBuilder rendererNodeBuilder = new RendererNodeBuilder();
+ rendererNodeBuilder.setKey(new RendererNodeKey(path))
+ .setNodePath(path);
+ return rendererNodeBuilder.build();
+ }
+
+ private InstanceIdentifier getMountpointIid(Node node) {
+ return InstanceIdentifier.builder(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(TOPOLOGY_ID))
+ .child(Node.class, new NodeKey(node.getNodeId())).build();
+ }
+
+ private boolean isCapableNetconfDevice(Node node, NetconfNode netconfAugmentation) {
+ if (netconfAugmentation.getAvailableCapabilities() == null ||
+ netconfAugmentation.getAvailableCapabilities().getAvailableCapability() == null ||
+ netconfAugmentation.getAvailableCapabilities().getAvailableCapability().isEmpty()) {
+ LOG.warn("Node {} does not contain any capabilities", node.getNodeId().getValue());
+ return true;
+ }
+ if (!capabilityCheck(netconfAugmentation.getAvailableCapabilities().getAvailableCapability())) {
+ LOG.warn("Node {} does not contain all capabilities required by io-xe-renderer",
+ node.getNodeId().getValue());
+ return true;
}
- InstanceIdentifier mountPointIid = getMountpointIid(topologyId, node);
+ return false;
+ }
+
+ private boolean capabilityCheck(final List<String> capabilities) {
+ for (String requiredCapability : requiredCapabilities) {
+ if (!capabilities.contains(requiredCapability)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ private DataBroker getNodeMountPoint(InstanceIdentifier mountPointIid) {
Optional<MountPoint> optionalObject = mountService.getMountPoint(mountPointIid);
MountPoint mountPoint;
if (optionalObject.isPresent()) {
return null;
}
- private InstanceIdentifier getMountpointIid(TopologyId topologyId, Node node) {
- return InstanceIdentifier.builder(NetworkTopology.class)
- .child(Topology.class, new TopologyKey(topologyId))
- .child(Node.class, new NodeKey(node.getNodeId())).build();
+ private NetconfNode getNodeAugmentation(Node node) {
+ NetconfNode netconfNode = node.getAugmentation(NetconfNode.class);
+ if (netconfNode == null) {
+ LOG.warn("Node {} is not a netconf device", node.getNodeId().getValue());
+ return null;
+ }
+ return netconfNode;
}
- private RendererNode remap(TopologyId topologyId, Node node) {
- InstanceIdentifier<Node> nodeIid = InstanceIdentifier.builder(NetworkTopology.class)
- .child(Topology.class, new TopologyKey(topologyId))
- .child(Node.class, new NodeKey(node.getNodeId())).build();
- RendererNodeBuilder rendererNodeBuilder = new RendererNodeBuilder();
- rendererNodeBuilder.setKey(new RendererNodeKey(nodeIid))
- .setNodePath(nodeIid);
- return rendererNodeBuilder.build();
- }
+ private class RequiredCapabilities {
- private boolean isNetconfDevice(Node node) {
- NetconfNode netconfAugmentation = node.getAugmentation(NetconfNode.class);
- if (netconfAugmentation == null) {
- LOG.debug("Node {} is not a netconf device", node.getNodeId().getValue());
- return false;
- }
- if (netconfAugmentation.getConnectionStatus().equals(NetconfNodeConnectionStatus.ConnectionStatus.Connected)) {
- LOG.info("Node {} ready", node.getNodeId().getValue());
- return true;
+ private static final String ned = "(urn:ios?revision=2016-03-08)ned";
+ private static final String tailfCommon = "(http://tail-f.com/yang/common?revision=2015-05-22)tailf-common";
+ private static final String tailfCliExtension = "(http://tail-f.com/yang/common?revision=2015-03-19)tailf-cli-extensions";
+ private static final String tailfMetaExtension = "(http://tail-f.com/yang/common?revision=2013-11-07)tailf-meta-extensions";
+ private static final String ietfYangTypes = "(urn:ietf:params:xml:ns:yang:ietf-yang-types?revision=2013-07-15)ietf-yang-types";
+ private static final String ietfInetTypes = "(urn:ietf:params:xml:ns:yang:ietf-inet-types?revision=2013-07-15)ietf-inet-types";
+
+ /**
+ * Initialize all common capabilities required by IOS-XE renderer. Any connected node is examined whether it's
+ * an appropriate device to handle configuration created by this renderer. A device must support all capabilities
+ * in list below.
+ *
+ * @return list of string representations of required capabilities
+ */
+ List<String> initializeRequiredCapabilities() {
+ String writableDataStore = "urn:ietf:params:netconf:capability:writable-running:1.0";
+ String capabilityEntries[] = {ned, tailfCommon, tailfCliExtension, tailfMetaExtension, ietfYangTypes,
+ ietfInetTypes, writableDataStore};
+ return Arrays.asList(capabilityEntries);
}
- LOG.info("Node {} not connected yet", node.getNodeId().getValue());
- return false;
}
}
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.manager.NodeManager;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.RendererName;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.Renderers;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.Renderer;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererNodes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererNodesBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.nodes.RendererNode;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.nodes.RendererNodeKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
rendererNodesCache = new ArrayList<>();
}
- public void write(RendererNode node) {
+ public void cache(RendererNode node) {
rendererNodesCache.add(node);
}
+ /**
+ * Put all cached items to data store
+ *
+ * @param dataBroker appropriate data provider
+ */
public void commitToDatastore(DataBroker dataBroker) {
RendererNodes rendererNodes = buildRendererNodes();
WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
- InstanceIdentifier<RendererNodes> Iid = InstanceIdentifier.builder(Renderers.class)
- .child(Renderer.class, new RendererKey(new RendererName("ios-xe-renderer"))) // TODO unify renderer name
- .child(RendererNodes.class)
- .build();
+ InstanceIdentifier<RendererNodes> iid = buildRendererNodesIid();
try {
- wtx.merge(LogicalDatastoreType.OPERATIONAL, Iid, rendererNodes, true);
+ wtx.merge(LogicalDatastoreType.OPERATIONAL, iid, rendererNodes, true);
CheckedFuture<Void, TransactionCommitFailedException> submitFuture = wtx.submit();
submitFuture.checkedGet();
// Clear cache
}
}
+ /**
+ * Removes all cached items from data store
+ *
+ * @param dataBroker appropriate data provider
+ */
+ public void removeFromDatastore(DataBroker dataBroker) {
+ WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
+ for (RendererNode nodeToRemove : rendererNodesCache) {
+ InstanceIdentifier<RendererNode> iid = buildRendererNodeIid(nodeToRemove);
+ try {
+ wtx.delete(LogicalDatastoreType.OPERATIONAL, iid);
+ CheckedFuture<Void, TransactionCommitFailedException> submitFuture = wtx.submit();
+ submitFuture.checkedGet();
+ // Clear cache
+ } catch (TransactionCommitFailedException e) {
+ LOG.error("Write transaction failed to {}", e.getMessage());
+ } catch (Exception e) {
+ LOG.error("Failed to .. {}", e.getMessage());
+ }
+ }
+ rendererNodesCache.clear();
+ }
+
+ private InstanceIdentifier<RendererNodes> buildRendererNodesIid() {
+ return InstanceIdentifier.builder(Renderers.class)
+ .child(Renderer.class, new RendererKey(new RendererName(NodeManager.iosXeRenderer))) // TODO unify renderer name
+ .child(RendererNodes.class)
+ .build();
+ }
+
+ private InstanceIdentifier<RendererNode> buildRendererNodeIid(RendererNode rendererNode) {
+ return InstanceIdentifier.builder(Renderers.class)
+ .child(Renderer.class, new RendererKey(new RendererName(NodeManager.iosXeRenderer))) // TODO unify renderer name
+ .child(RendererNodes.class)
+ .child(RendererNode.class, new RendererNodeKey(rendererNode.getNodePath()))
+ .build();
+ }
+
private RendererNodes buildRendererNodes() {
RendererNodesBuilder rendererNodesBuilder = new RendererNodesBuilder();
rendererNodesBuilder.setRendererNode(new ArrayList<>(rendererNodesCache));
return rendererNodesBuilder.build();
}
-
}
import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
import org.opendaylight.groupbasedpolicy.renderer.ios_xe_provider.impl.manager.NodeManager;
import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopologyBuilder;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
-import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyBuilder;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
/**
@Mock
private NodeManager nodeManager;
@Mock
- private ListenerRegistration<DataTreeChangeListener<NetworkTopology>> listenerRegistration;
+ private ListenerRegistration<DataTreeChangeListener<Node>> listenerRegistration;
@Mock
- private DataTreeModification<NetworkTopology> dataTreeModification;
+ private DataTreeModification<Node> dataTreeModification;
@Mock
- private DataObjectModification<NetworkTopology> rootNode;
+ private DataObjectModification<Node> rootNode;
private IosXeCapableNodeListenerImpl listener;
@Before
public void setUp() throws Exception {
Mockito.when(dataBroker.registerDataTreeChangeListener(
- Matchers.<DataTreeIdentifier<NetworkTopology>>any(),
- Matchers.<DataTreeChangeListener<NetworkTopology>>any()))
+ Matchers.<DataTreeIdentifier<Node>>any(),
+ Matchers.<DataTreeChangeListener<Node>>any()))
.thenReturn(listenerRegistration);
listener = new IosXeCapableNodeListenerImpl(dataBroker, nodeManager);
Mockito.verify(dataBroker).registerDataTreeChangeListener(
@Test
public void testOnDataTreeChanged_add() throws Exception {
- final NetworkTopology networkTopology = createNetworkTopology("topology-id-1");
+ final Node topologyNode = createNetworkTopologyNode("topology-node-id-1");
Mockito.when(dataTreeModification.getRootNode()).thenReturn(rootNode);
- Mockito.when(rootNode.getDataBefore()).thenReturn(networkTopology);
+ Mockito.when(rootNode.getDataBefore()).thenReturn(topologyNode);
Mockito.when(rootNode.getDataAfter()).thenReturn(null);
listener.onDataTreeChanged(Collections.singleton(dataTreeModification));
- Mockito.verify(nodeManager).syncNodes(null, networkTopology.getTopology());
+ Mockito.verify(nodeManager).syncNodes(null, topologyNode);
}
@Test
public void testOnDataTreeChanged_update() throws Exception {
- final NetworkTopology networkTopologyBefore = createNetworkTopology("topology-id-1");
- final NetworkTopology networkTopologyAfter = createNetworkTopology("topology-id-2");
+ final Node topologyNodeBefore = createNetworkTopologyNode("topology-node-id-1");
+ final Node topologyNodeAfter = createNetworkTopologyNode("topology-node-id-2");
Mockito.when(dataTreeModification.getRootNode()).thenReturn(rootNode);
- Mockito.when(rootNode.getDataBefore()).thenReturn(networkTopologyBefore);
- Mockito.when(rootNode.getDataAfter()).thenReturn(networkTopologyAfter);
+ Mockito.when(rootNode.getDataBefore()).thenReturn(topologyNodeBefore);
+ Mockito.when(rootNode.getDataAfter()).thenReturn(topologyNodeAfter);
listener.onDataTreeChanged(Collections.singleton(dataTreeModification));
- Mockito.verify(nodeManager).syncNodes(networkTopologyAfter.getTopology(), networkTopologyBefore.getTopology());
+ Mockito.verify(nodeManager).syncNodes(topologyNodeAfter, topologyNodeBefore);
}
@Test
public void testOnDataTreeChanged_remove() throws Exception {
- final NetworkTopology networkTopology = createNetworkTopology("topology-id-2");
+ final Node topologyNode = createNetworkTopologyNode("topology-node-id-2");
Mockito.when(dataTreeModification.getRootNode()).thenReturn(rootNode);
Mockito.when(rootNode.getDataBefore()).thenReturn(null);
- Mockito.when(rootNode.getDataAfter()).thenReturn(networkTopology);
+ Mockito.when(rootNode.getDataAfter()).thenReturn(topologyNode);
listener.onDataTreeChanged(Collections.singleton(dataTreeModification));
- Mockito.verify(nodeManager).syncNodes(networkTopology.getTopology(), null);
+ Mockito.verify(nodeManager).syncNodes(topologyNode, null);
}
- private NetworkTopology createNetworkTopology(final String topologyId) {
- return new NetworkTopologyBuilder()
- .setTopology(Collections.singletonList(new TopologyBuilder()
- .setTopologyId(new TopologyId(topologyId))
- .build()))
+ private Node createNetworkTopologyNode(final String nodeId) {
+ return new NodeBuilder()
+ .setNodeId(new NodeId(nodeId))
.build();
}
@Test
public void testCommitToDatastore_with_node() throws Exception {
final RendererNode node = new RendererNodeBuilder().build();
- nodeWriter.write(node);
+ nodeWriter.cache(node);
nodeWriter.commitToDatastore(dataBroker);
commonChecks();
<artifactId>powermock-api-mockito</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>com.sun.jersey.jersey-test-framework</groupId>
+ <artifactId>jersey-test-framework-grizzly2</artifactId>
+ <scope>test</scope>
+ </dependency>
</dependencies>
// key is String (not a full IpAddress) because
// we will get String from REST query to sFlow
private static ConcurrentMap<String, EndpointL3> endpointL3ByIpMap = new ConcurrentHashMap<>();
+ private static final int CONNECT_TIMEOUT_MILLISEC = 20000;
+ private static final int READ_TIMEOUT_MILLISEC = 30000;
private static final Logger LOG = LoggerFactory.getLogger(OFStatisticsManager.class);
epgsByContractId.put(contractId, Pair.of(consEpgKey, provEpgKey));
boolean isFlowCacheNew = flowCacheNames.add(flowCacheName);
if (isFlowCacheNew) {
- SFlowRTConnection sFlowRTConnection = new SFlowRTConnection(executor, sflowCollectorUri, flowCache);
+ SFlowRTConnection sFlowRTConnection = new SFlowRTConnection(executor, sflowCollectorUri, flowCache, new JsonRestClient(sflowCollectorUri, CONNECT_TIMEOUT_MILLISEC,
+ READ_TIMEOUT_MILLISEC));
ScheduledFuture<?> collectStatsTask = this.executor.scheduleWithFixedDelay(new ReadGbpFlowCacheTask(flowCacheName, sFlowRTConnection,
statisticsManager, MAX_FLOWS, MIN_VALUE_IN_FLOW, AGG_MODE), 0, delay, TimeUnit.SECONDS);
collectStatsTasks.add(collectStatsTask);
import org.opendaylight.groupbasedpolicy.api.StatisticsManager;
import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.flowcache.FlowCacheData;
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.util.SFlowQueryParams;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Type LIST_OF_FLOW_CACHE_DATA = new TypeToken<List<FlowCacheData>>() {}.getType();
private static final Gson GSON = new Gson();
- private static final String MAX_FLOWS_PARAM = "maxFlows";
- private static final String MIN_VALUE_PARAM = "minValue";
- private static final String AGG_MODE_PARAM = "aggMode";
private final SFlowRTConnection sFlowRTConnection;
private final StatisticsManager statisticsManager;
@Override
public void run() {
MultivaluedMap<String, String> params = new MultivaluedMapImpl();
- params.add(MAX_FLOWS_PARAM, maxFlows);
- params.add(MIN_VALUE_PARAM, minValue);
- params.add(AGG_MODE_PARAM, aggMode);
+ params.add(SFlowQueryParams.MAX_FLOWS, maxFlows);
+ params.add(SFlowQueryParams.MIN_VALUE, minValue);
+ params.add(SFlowQueryParams.AGG_MODE, aggMode);
JsonRestClientResponse result = sFlowRTConnection.get(path, params);
if (result != null && result.getJsonResponse() != null) {
ResolvedPolicy resolvedPolicy = rootNode.getDataAfter();
Map<InstanceIdentifier<Classifier>, Classifier> classifierByIid =
resolveClassifiers(resolvedPolicy, rootIdentifier);
- for (Entry<InstanceIdentifier<Classifier>, Classifier> classfierEntry : classifierByIid.entrySet()) {
- LOG.trace("New classifier created: {}\n{}", classfierEntry.getKey(), classfierEntry.getValue());
- ofStatsManager.pullStatsForClassifier(classfierEntry.getKey(), classfierEntry.getValue());
+ for (Entry<InstanceIdentifier<Classifier>, Classifier> classifierEntry : classifierByIid.entrySet()) {
+ LOG.trace("New classifier created: {}\n{}", classifierEntry.getKey(),
+ classifierEntry.getValue());
+ ofStatsManager.pullStatsForClassifier(classifierEntry.getKey(),
+ classifierEntry.getValue());
}
}
private static final Logger LOG = LoggerFactory.getLogger(SFlowRTConnection.class);
- private static final int CONNECT_TIMEOUT_MILLISEC = 20000;
- private static final int READ_TIMEOUT_MILLISEC = 30000;
private static final String GET = "GET";
private static final String PUT = "PUT";
private static final String DELETE = "DELETE";
+ static final String EX_MSG_NOT_INITIALIZED = "SFlowRTConnection is not initialized.";
+
private final FlowCache flowCache;
private JsonRestClient client;
private boolean isInitialized = false;
private final ScheduledExecutorService executor;
private final String collectorUri;
- public SFlowRTConnection(ScheduledExecutorService executor, String collectorUri, FlowCache flowCache) {
+ public SFlowRTConnection(ScheduledExecutorService executor, String collectorUri, FlowCache flowCache, JsonRestClient client) {
this.executor = Preconditions.checkNotNull(executor);
this.collectorUri = Preconditions.checkNotNull(collectorUri);
this.flowCache = Preconditions.checkNotNull(flowCache);
-
- this.client = new JsonRestClient(collectorUri, CONNECT_TIMEOUT_MILLISEC,
- READ_TIMEOUT_MILLISEC);
+ this.client = client;
initialize();
}
public JsonRestClientResponse get(String path,
MultivaluedMap<String, String> params) {
if (!isInitialized()) {
- throw new IllegalStateException("SFlowRTConnection is not initialized.");
+ throw new IllegalStateException(EX_MSG_NOT_INITIALIZED);
}
try {
JsonRestClientResponse responce = client.get(path, params);
@Nullable
public JsonRestClientResponse put(String path, String someJson) {
if (!isInitialized()) {
- throw new IllegalStateException("SFlowRTConnection is not initialized.");
+ throw new IllegalStateException(EX_MSG_NOT_INITIALIZED);
}
return putWithoutInitCheck(path, someJson);
}
public JsonRestClientResponse delete(String path) {
if (!isInitialized()) {
- throw new IllegalStateException("SFlowRTConnection is not initialized.");
+ throw new IllegalStateException(EX_MSG_NOT_INITIALIZED);
}
try {
JsonRestClientResponse responce = client.delete(path);
--- /dev/null
+/*
+ * Copyright (c) 2016 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.groupbasedpolicy.renderer.ofoverlay.statistics.util;
+
+public class SFlowQueryParams {
+
+ public static final String MAX_FLOWS = "maxFlows";
+ public static final String MIN_VALUE = "minValue";
+ public static final String AGG_MODE = "aggMode";
+
+}
package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.arp;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assume.assumeNoException;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
import java.net.InetAddress;
import java.util.Collections;
import java.util.concurrent.Future;
-import org.junit.Assert;
+import com.google.common.util.concurrent.UncheckedExecutionException;
import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
@Before
public void init() {
- PacketProcessingService packetService = Mockito.mock(PacketProcessingService.class);
- flowService = Mockito.mock(SalFlowService.class);
- rpcRegistry = Mockito.mock(RpcProviderRegistry.class);
- Mockito.when(rpcRegistry.getRpcService(PacketProcessingService.class)).thenReturn(packetService);
- Mockito.when(rpcRegistry.getRpcService(SalFlowService.class)).thenReturn(flowService);
+ PacketProcessingService packetService = mock(PacketProcessingService.class);
+ flowService = mock(SalFlowService.class);
+ rpcRegistry = mock(RpcProviderRegistry.class);
+ when(rpcRegistry.getRpcService(PacketProcessingService.class)).thenReturn(packetService);
+ when(rpcRegistry.getRpcService(SalFlowService.class)).thenReturn(flowService);
}
@SuppressWarnings("unchecked")
.build()));
// test without key
- ReadOnlyTransaction rtx = Mockito.mock(ReadOnlyTransaction.class);
- broker = Mockito.mock(DataBroker.class);
+ ReadOnlyTransaction rtx = mock(ReadOnlyTransaction.class);
+ broker = mock(DataBroker.class);
arpTasker = new ArpTasker(rpcRegistry, broker);
- epL3.setKey(new EndpointL3Key(Mockito.mock(IpAddress.class), null));
+ epL3.setKey(new EndpointL3Key(mock(IpAddress.class), null));
arpTasker.addMacForL3EpAndCreateEp(epL3.build());
- Mockito.verify(broker, Mockito.never()).newReadOnlyTransaction();
+ verify(broker, never()).newReadOnlyTransaction();
// test without node with external interface
epL3.setKey(key);
- Mockito.when(broker.newReadOnlyTransaction()).thenReturn(rtx);
+ when(broker.newReadOnlyTransaction()).thenReturn(rtx);
CheckedFuture<Optional<DataObject>, ReadFailedException> future =
Futures.immediateCheckedFuture(Optional.<DataObject>absent());
- Mockito.when(rtx.read(Matchers.eq(LogicalDatastoreType.CONFIGURATION), Matchers.any(InstanceIdentifier.class)))
+ when(rtx.read(Matchers.eq(LogicalDatastoreType.CONFIGURATION),
+ any(InstanceIdentifier.class)))
.thenReturn(future);
arpTasker.addMacForL3EpAndCreateEp(epL3.build());
- Mockito.verify(broker).newReadOnlyTransaction();
- Mockito.verify(rtx).close();
+ verify(broker).newReadOnlyTransaction();
+ verify(rtx).close();
// test correct
broker = getDataBroker();
.child(NodeConnector.class, new NodeConnectorKey(connectorId))
.build(),
connector.build(), true);
- wtx.put(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.builder(Tenants.class).build(), tenants.build(),
- true);
+ // ignoring a Windows-specific bug
+ try {
+ wtx.put(LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.builder(Tenants.class).build(), tenants.build(), true);
+ } catch (UncheckedExecutionException e) {
+ assumeNoException(e);
+ }
wtx.submit().get();
- Future<RpcResult<AddFlowOutput>> flowFuture = Mockito.mock(Future.class);
- Mockito.when(flowService.addFlow(Mockito.any(AddFlowInput.class))).thenReturn(flowFuture);
+ Future<RpcResult<AddFlowOutput>> flowFuture = mock(Future.class);
+ when(flowService.addFlow(any(AddFlowInput.class))).thenReturn(flowFuture);
epL3.setNetworkContainment(domainId).setTenant(tenantId);
arpTasker.addMacForL3EpAndCreateEp(epL3.build());
ArgumentCaptor<AddFlowInput> argument = ArgumentCaptor.forClass(AddFlowInput.class);
- Mockito.verify(flowService).addFlow(argument.capture());
+ verify(flowService).addFlow(argument.capture());
AddFlowInput result = argument.getValue();
- Assert.assertEquals(EtherTypes.ARP.intValue(),
- result.getMatch().getEthernetMatch().getEthernetType().getType().getValue().intValue());
+ assertEquals(EtherTypes.ARP.intValue(), result.getMatch()
+ .getEthernetMatch()
+ .getEthernetType()
+ .getType()
+ .getValue()
+ .intValue());
ArpMatch match = (ArpMatch)result.getMatch().getLayer3Match();
- Assert.assertEquals(ArpOperation.REPLY.intValue(),match.getArpOp().intValue());
- Assert.assertEquals("192.168.0.254/32",match.getArpTargetTransportAddress().getValue());
- Assert.assertEquals("192.168.0.1/32", match.getArpSourceTransportAddress().getValue());
- Assert.assertEquals(connectorId, result.getMatch().getInPort());
- Assert.assertEquals(new NodeRef(InstanceIdentifier.builder(Nodes.class)
- .child(Node.class, node.getKey()).build()), result.getNode());
+ assertEquals(ArpOperation.REPLY.intValue(), match.getArpOp().intValue());
+ assertEquals("192.168.0.254/32", match.getArpTargetTransportAddress().getValue());
+ assertEquals("192.168.0.1/32", match.getArpSourceTransportAddress().getValue());
+ assertEquals(connectorId, result.getMatch().getInPort());
+ assertEquals(new NodeRef(
+ InstanceIdentifier.builder(Nodes.class).child(Node.class, node.getKey()).build()),
+ result.getNode());
// onPacketReceived
Arp arp = new Arp();
arpTasker.onPacketReceived(packet);
rtx = broker.newReadOnlyTransaction();
Optional<EndpointL3> optional = rtx.read(LogicalDatastoreType.OPERATIONAL, epL3Iid).get();
- Assert.assertTrue(optional.isPresent());
+ assertTrue(optional.isPresent());
EndpointL3 epl3 = optional.get();
- Assert.assertArrayEquals(sha, HexEncode.bytesFromHexString(epl3.getMacAddress().getValue()));
- Assert.assertEquals(l2domain.getId(), epl3.getL2Context());
+ assertArrayEquals(sha, HexEncode.bytesFromHexString(epl3.getMacAddress().getValue()));
+ assertEquals(l2domain.getId(), epl3.getL2Context());
Optional<Endpoint> optionalEp = rtx.read(LogicalDatastoreType.OPERATIONAL,
IidFactory.endpointIid(l2domainId, new MacAddress("00:00:00:00:00:01"))).get();
- Assert.assertTrue(optionalEp.isPresent());
- Assert.assertEquals(new OfOverlayContextBuilder(augment).build(), optionalEp.get().getAugmentation(OfOverlayContext.class));
+ assertTrue(optionalEp.isPresent());
+ assertEquals(new OfOverlayContextBuilder(augment).build(),
+ optionalEp.get().getAugmentation(OfOverlayContext.class));
}
}
package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.arp;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
import java.net.InetAddress;
import org.junit.Assert;
Assert.assertTrue(
result.contains("getTargetProtocolAddress()=" + InetAddress.getByAddress(tpa).getHostAddress()));
}
+
+ @Test
+ public void testBytesToMac(){
+ byte[] macBytes = {0,1,0,1,0,1};
+ assertEquals(new MacAddress("00:01:00:01:00:01"), ArpUtils.bytesToMac(macBytes));
+ assertNull(ArpUtils.bytesToMac(null));
+ }
}
endpointManager = mock(EndpointManager.class);
DataBroker dataProvider = mock(DataBroker.class);
- EndpointManagerListener endpointManagerListener =
- new EndpointManagerListener(dataProvider, endpointManager);
+ EndpointManagerListener endpointManagerListener = new EndpointManagerListener(dataProvider, endpointManager);
tester = new DataChangeListenerTester(endpointManagerListener);
tester.setRemovedPath(endpointId);
}
tester.callOnDataChanged();
verify(endpointManager, times(3)).processEndpoint(any(Endpoint.class), any(Endpoint.class));
- verify(endpointManager, never()).processL3Endpoint(any(EndpointL3.class),
- any(EndpointL3.class));
+ verify(endpointManager, never()).processL3Endpoint(any(EndpointL3.class), any(EndpointL3.class));
}
@Test
tester.callOnDataChanged();
verify(endpointManager, never()).processEndpoint(any(Endpoint.class), any(Endpoint.class));
- verify(endpointManager, times(3)).processL3Endpoint(any(EndpointL3.class),
- any(EndpointL3.class));
+ verify(endpointManager, times(3)).processL3Endpoint(any(EndpointL3.class), any(EndpointL3.class));
}
@Test
tester.callOnDataChanged();
verify(endpointManager, never()).processEndpoint(any(Endpoint.class), any(Endpoint.class));
- verify(endpointManager, never()).processL3Endpoint(any(EndpointL3.class),
- any(EndpointL3.class));
+ verify(endpointManager, never()).processL3Endpoint(any(EndpointL3.class), any(EndpointL3.class));
}
}
package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
-import java.lang.reflect.Method;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
-import java.util.UUID;
import java.util.concurrent.ScheduledExecutorService;
-import org.junit.Assert;
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
import org.opendaylight.controller.md.sal.binding.api.NotificationService;
import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.l3endpoint.rev151217.NatAddress;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayContext;
import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayL3Context;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.Tenant;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.ForwardingContext;
-import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.forwarding.context.L2BridgeDomain;
import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
import org.opendaylight.yangtools.concepts.ListenerRegistration;
import org.opendaylight.yangtools.yang.binding.DataObject;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.RpcService;
-import com.google.common.base.Optional;
-import com.google.common.util.concurrent.CheckedFuture;
-
public class EndpointManagerTest {
private EndpointManager manager;
private EndpointL3 newL3Ep;
private Optional<Endpoints> optionalRead;
+ // TODO get rid of unnecessary mocks (endpoint1, endpoint2, their parameters)
+
@SuppressWarnings("unchecked")
@Before
public void initialisation() throws Exception {
when(dataProvider.newWriteOnlyTransaction()).thenReturn(writeTransaction);
CheckedFuture<Void, TransactionCommitFailedException> checkedFutureWrite = mock(CheckedFuture.class);
when(writeTransaction.submit()).thenReturn(checkedFutureWrite);
- BindingAwareBroker.RpcRegistration<EndpointService> rpcRegistration = mock(BindingAwareBroker.RpcRegistration.class);
+ BindingAwareBroker.RpcRegistration<EndpointService> rpcRegistration =
+ mock(BindingAwareBroker.RpcRegistration.class);
listenerReg = mock(ListenerRegistration.class);
when(dataProvider.registerDataChangeListener(any(LogicalDatastoreType.class), any(InstanceIdentifier.class),
any(DataChangeListener.class), any(DataChangeScope.class))).thenReturn(listenerReg);
ReadOnlyTransaction readTransaction = mock(ReadOnlyTransaction.class);
when(dataProvider.newReadOnlyTransaction()).thenReturn(readTransaction);
CheckedFuture<Optional<Endpoints>, ReadFailedException> checkedFutureRead = mock(CheckedFuture.class);
- when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
- checkedFutureRead);
+ when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
+ .thenReturn(checkedFutureRead);
optionalRead = mock(Optional.class);
when(checkedFutureRead.checkedGet()).thenReturn(optionalRead);
when(optionalRead.isPresent()).thenReturn(false);
@Test
public void getGroupsForNodeTest() {
- Assert.assertTrue(manager.getGroupsForNode(nodeId1).isEmpty());
+ assertTrue(manager.getGroupsForNode(nodeId1).isEmpty());
manager.processEndpoint(null, endpoint1);
- Assert.assertFalse(manager.getGroupsForNode(nodeId1).isEmpty());
+ assertFalse(manager.getGroupsForNode(nodeId1).isEmpty());
}
@Test
public void getNodesForGroupTest() {
EgKey egKey = mock(EgKey.class);
Set<NodeId> nodesForGroup = manager.getNodesForGroup(egKey);
- Assert.assertNotNull(nodesForGroup);
- Assert.assertTrue(nodesForGroup.isEmpty());
+ assertNotNull(nodesForGroup);
+ assertTrue(nodesForGroup.isEmpty());
}
@Test
public void getEndpointsForNodeTestNodeIdEgKey() {
EgKey egKey = new EgKey(tenantId, endpointGroupId);
- Assert.assertTrue(manager.getEndpointsForNode(nodeId1, egKey).isEmpty());
+ assertTrue(manager.getEndpointsForNode(nodeId1, egKey).isEmpty());
manager.processEndpoint(null, endpoint1);
- Assert.assertFalse(manager.getEndpointsForNode(nodeId1, egKey).isEmpty());
+ assertFalse(manager.getEndpointsForNode(nodeId1, egKey).isEmpty());
}
@Test
public void getEndpointsForNodeTestNodeId() {
- Assert.assertTrue(manager.getEndpointsForNode(nodeId1).isEmpty());
+ assertTrue(manager.getEndpointsForNode(nodeId1).isEmpty());
manager.processEndpoint(null, endpoint1);
- Assert.assertFalse(manager.getEndpointsForNode(nodeId1).isEmpty());
+ assertFalse(manager.getEndpointsForNode(nodeId1).isEmpty());
}
@Test
public void getEndpoint() {
EpKey epKey = new EpKey(endpoint1.getL2Context(), endpoint1.getMacAddress());
manager.processEndpoint(null, endpoint1);
- Assert.assertEquals(endpoint1, manager.getEndpoint(epKey));
+ assertEquals(endpoint1, manager.getEndpoint(epKey));
}
@SuppressWarnings("unchecked")
ReadOnlyTransaction readTransaction = mock(ReadOnlyTransaction.class);
when(dataProvider.newReadOnlyTransaction()).thenReturn(readTransaction);
CheckedFuture<Optional<Endpoints>, ReadFailedException> resultFuture = mock(CheckedFuture.class);
- when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(
- resultFuture);
+ when(readTransaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
+ .thenReturn(resultFuture);
Optional<Endpoints> optional = mock(Optional.class);
when(resultFuture.checkedGet()).thenReturn(optional);
when(optional.isPresent()).thenReturn(true);
when(endpointL3Prefix.getTenant()).thenReturn(tenantId);
Collection<EndpointL3Prefix> result = manager.getEndpointsL3PrefixForTenant(tenantId);
- Assert.assertTrue(result.contains(endpointL3Prefix));
+ assertTrue(result.contains(endpointL3Prefix));
}
@SuppressWarnings("unchecked")
ReadOnlyTransaction transaction = mock(ReadOnlyTransaction.class);
when(dataProvider.newReadOnlyTransaction()).thenReturn(transaction);
CheckedFuture<Optional<Endpoints>, ReadFailedException> checkedFuture = mock(CheckedFuture.class);
- when(transaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class))).thenReturn(checkedFuture);
+ when(transaction.read(any(LogicalDatastoreType.class), any(InstanceIdentifier.class)))
+ .thenReturn(checkedFuture);
Optional<Endpoints> optional = mock(Optional.class);
when(checkedFuture.checkedGet()).thenReturn(optional);
when(optional.isPresent()).thenReturn(false);
- Assert.assertNull(manager.getEndpointsFromDataStore());
+ assertNull(manager.getEndpointsFromDataStore());
when(optional.isPresent()).thenReturn(true);
Endpoints endpoints = mock(Endpoints.class);
when(optional.get()).thenReturn(endpoints);
- Assert.assertEquals(endpoints, manager.getEndpointsFromDataStore());
+ assertEquals(endpoints, manager.getEndpointsFromDataStore());
manager = new EndpointManager(null, rpcRegistry, notificationService, executor, switchManager);
- Assert.assertNull(manager.getEndpointsFromDataStore());
+ assertNull(manager.getEndpointsFromDataStore());
}
@Test
public void getL3EndpointsTestEndpointsNull() throws Exception {
- Assert.assertNull(manager.getL3Endpoints());
+ assertNull(manager.getL3Endpoints());
}
@Test
when(optionalRead.get()).thenReturn(endpoints);
when(endpoints.getEndpointL3()).thenReturn(null);
- Assert.assertNull(manager.getL3Endpoints());
+ assertNull(manager.getL3Endpoints());
}
@Test
List<EndpointL3> endpointL3List = Collections.singletonList(mock(EndpointL3.class));
when(endpoints.getEndpointL3()).thenReturn(endpointL3List);
- Assert.assertEquals(endpointL3List, manager.getL3Endpoints());
+ assertEquals(endpointL3List, manager.getL3Endpoints());
}
@Test
when(endpointL3.getMacAddress()).thenReturn(mock(MacAddress.class));
Map<EndpointKey, EndpointL3> result = manager.getL3EpWithNatByL2Key();
- Assert.assertTrue(result.containsValue(endpointL3));
+ assertTrue(result.containsValue(endpointL3));
}
@Test
public void getL3EpWithNatByL2KeyTestL3EpsNull() {
Map<EndpointKey, EndpointL3> result = manager.getL3EpWithNatByL2Key();
- Assert.assertTrue(result.isEmpty());
+ assertTrue(result.isEmpty());
}
@Test
when(endpointL3.getMacAddress()).thenReturn(null);
Map<EndpointKey, EndpointL3> result = manager.getL3EpWithNatByL2Key();
- Assert.assertTrue(result.isEmpty());
+ assertTrue(result.isEmpty());
}
@Test
when(endpointL3.getMacAddress()).thenReturn(mock(MacAddress.class));
Map<EndpointKey, EndpointL3> result = manager.getL3EpWithNatByL2Key();
- Assert.assertTrue(result.isEmpty());
+ assertTrue(result.isEmpty());
}
@Test
public void getEndpointsForGroupTest() {
EgKey newEgKey = new EgKey(tenantId, endpointGroupId);
- Assert.assertTrue(manager.getEndpointsForGroup(newEgKey).isEmpty());
+ assertTrue(manager.getEndpointsForGroup(newEgKey).isEmpty());
manager.processEndpoint(null, endpoint1);
- Assert.assertFalse(manager.getEndpointsForGroup(newEgKey).isEmpty());
+ assertFalse(manager.getEndpointsForGroup(newEgKey).isEmpty());
}
@Test
public void getConditionsForEndpoint() {
Endpoint endpoint = mock(Endpoint.class);
when(endpoint.getCondition()).thenReturn(null);
- Assert.assertTrue(manager.getConditionsForEndpoint(endpoint).isEmpty());
+ assertTrue(manager.getConditionsForEndpoint(endpoint).isEmpty());
List<ConditionName> conditionNameList = Collections.singletonList(mock(ConditionName.class));
when(endpoint.getCondition()).thenReturn(conditionNameList);
- Assert.assertEquals(conditionNameList, manager.getConditionsForEndpoint(endpoint));
+ assertEquals(conditionNameList, manager.getConditionsForEndpoint(endpoint));
}
@Test
when(endpointL3Key.getIpAddress()).thenReturn(ipAddress);
when(newL3Ep.getIpAddress()).thenReturn(new IpAddress(new Ipv4Address("1.1.1.1")));
manager.processL3Endpoint(null, newL3Ep);
- verify(endpointListener,never()).endpointUpdated(any(EpKey.class));
+ verify(endpointListener, never()).endpointUpdated(any(EpKey.class));
}
@Test
when(endpointL3Key.getIpAddress()).thenReturn(ipAddress);
when(newL3Ep.getIpAddress()).thenReturn(new IpAddress(new Ipv4Address("1.1.1.1")));
manager.processL3Endpoint(null, newL3Ep);
- verify(endpointListener,never()).endpointUpdated(any(EpKey.class));
+ verify(endpointListener, never()).endpointUpdated(any(EpKey.class));
}
@Test
when(newL3Ep.getIpAddress()).thenReturn(null);
when(newL3Ep.getIpAddress()).thenReturn(new IpAddress(new Ipv4Address("1.1.1.1")));
manager.processL3Endpoint(null, newL3Ep);
- verify(endpointListener,never()).endpointUpdated(any(EpKey.class));
+ verify(endpointListener, never()).endpointUpdated(any(EpKey.class));
}
@Test
verify(endpointListener).endpointUpdated(any(EpKey.class));
}
+ @Test
+ public void updateEndpointL3TestUpdate() throws Exception {
+ when(oldL3Ep.getIpAddress()).thenReturn(new IpAddress(new Ipv4Address("1.1.1.1")));
+
+ when(newL3Ep.getTenant()).thenReturn(mock(TenantId.class));
+ when(newL3Ep.getEndpointGroup()).thenReturn(mock(EndpointGroupId.class));
+ when(newL3Ep.getL3Context()).thenReturn(mock(L3ContextId.class));
+ when(newL3Ep.getIpAddress()).thenReturn(mock(IpAddress.class));
+
+ OfOverlayL3Context ofOverlayL3Context = mock(OfOverlayL3Context.class);
+ when(newL3Ep.getAugmentation(OfOverlayL3Context.class)).thenReturn(ofOverlayL3Context);
+
+ when(newL3Ep.getNetworkContainment()).thenReturn(null);
+
+ when(newL3Ep.getL2Context()).thenReturn(mock(L2BridgeDomainId.class));
+ when(newL3Ep.getMacAddress()).thenReturn(mock(MacAddress.class));
+ when(newL3Ep.getIpAddress()).thenReturn(new IpAddress(new Ipv4Address("1.1.1.1")));
+
+ manager.processL3Endpoint(null, oldL3Ep);
+ manager.processL3Endpoint(oldL3Ep, newL3Ep);
+
+ verify(endpointListener).endpointUpdated(any(EpKey.class));
+ }
+
@Test
public void updateEndpointTestNewEndpointRemove() {
Collection<Endpoint> collection;
verify(endpointListener).endpointUpdated(any(EpKey.class));
verify(endpointListener).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
collection = manager.getEndpointsForGroup(new EgKey(tenantId, endpointGroupId));
- Assert.assertFalse(collection.isEmpty());
+ assertFalse(collection.isEmpty());
manager.processEndpoint(endpoint2, null);
verify(endpointListener, times(2)).endpointUpdated(any(EpKey.class));
verify(endpointListener, times(2)).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
collection = manager.getEndpointsForGroup(new EgKey(tenantId, endpointGroupId));
- Assert.assertTrue(collection.isEmpty());
+ assertTrue(collection.isEmpty());
}
@Test
// create: node1, update: node1 -> node2
verify(endpointListener, times(3)).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
collection = manager.getEndpointsForGroup(new EgKey(tenantId, endpointGroupId));
- Assert.assertFalse(collection.isEmpty());
+ assertFalse(collection.isEmpty());
}
/**
verify(endpointListener, times(2)).endpointUpdated(any(EpKey.class));
verify(endpointListener, times(1)).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
collection = manager.getEndpointsForGroup(new EgKey(tenantId, endpointGroupId));
- Assert.assertTrue(collection.isEmpty());
+ assertTrue(collection.isEmpty());
collection = manager.getEndpointsForGroup(new EgKey(tenantId, otherEndpointGroupId));
- Assert.assertFalse(collection.isEmpty());
+ assertFalse(collection.isEmpty());
}
/**
// create: node1, update: node1 -> node2
verify(endpointListener, times(3)).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
collection = manager.getEndpointsForGroup(new EgKey(tenantId, endpointGroupId));
- Assert.assertTrue(collection.isEmpty());
+ assertTrue(collection.isEmpty());
collection = manager.getEndpointsForGroup(new EgKey(tenantId, otherEndpointGroupId));
- Assert.assertFalse(collection.isEmpty());
+ assertFalse(collection.isEmpty());
}
/**
verify(endpointListener, times(2)).endpointUpdated(any(EpKey.class));
verify(endpointListener, times(2)).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
collection = manager.getEndpointsForGroup(new EgKey(tenantId, endpointGroupId));
- Assert.assertTrue(collection.isEmpty());
+ assertTrue(collection.isEmpty());
}
/**
verify(endpointListener).endpointUpdated(any(EpKey.class));
verify(endpointListener).nodeEndpointUpdated(any(NodeId.class), any(EpKey.class));
collection = manager.getEndpointsForGroup(new EgKey(tenantId, endpointGroupId));
- Assert.assertFalse(collection.isEmpty());
+ assertFalse(collection.isEmpty());
}
@Test
verify(listenerReg, times(3)).close();
}
- //**************
- //Helper Functions
- //**************
+ // **************
+ // Helper Functions
+ // **************
@Test
public void getEgKeyTest() {
- Assert.assertNotNull(manager.getEgKey(endpoint1));
- Assert.assertNull(manager.getEgKey(null));
+ assertNotNull(manager.getEgKey(endpoint1));
+ assertNull(manager.getEgKey(null));
when(endpoint1.getTenant()).thenReturn(null);
- Assert.assertNull(manager.getEgKey(endpoint1));
+ assertNull(manager.getEgKey(endpoint1));
when(endpoint1.getTenant()).thenReturn(tenantId);
when(endpoint1.getEndpointGroup()).thenReturn(null);
- Assert.assertNull(manager.getEgKey(endpoint1));
+ assertNull(manager.getEgKey(endpoint1));
when(endpoint1.getEndpointGroup()).thenReturn(endpointGroupId);
when(endpoint1.getEndpointGroups()).thenReturn(null);
- Assert.assertNotNull(manager.getEgKey(endpoint1));
+ assertNotNull(manager.getEgKey(endpoint1));
when(endpoint1.getEndpointGroup()).thenReturn(null);
- Assert.assertNull(manager.getEgKey(endpoint1));
+ assertNull(manager.getEgKey(endpoint1));
when(endpoint1.getEndpointGroup()).thenReturn(endpointGroupId);
when(endpoint1.getL2Context()).thenReturn(null);
- Assert.assertNull(manager.getEgKey(endpoint1));
+ assertNull(manager.getEgKey(endpoint1));
when(endpoint1.getL2Context()).thenReturn(l2BridgeDomainId);
when(endpoint1.getMacAddress()).thenReturn(null);
- Assert.assertNull(manager.getEgKey(endpoint1));
+ assertNull(manager.getEgKey(endpoint1));
}
@Test
when(endpoint.getEndpointGroups()).thenReturn(null);
egKeys = manager.getEgKeysForEndpoint(endpoint);
- Assert.assertTrue(egKeys.isEmpty());
+ assertTrue(egKeys.isEmpty());
EndpointGroupId endpointGroupId = mock(EndpointGroupId.class);
when(endpoint.getEndpointGroup()).thenReturn(endpointGroupId);
egKeys = manager.getEgKeysForEndpoint(endpoint);
- Assert.assertEquals(1, egKeys.size());
+ assertEquals(1, egKeys.size());
EndpointGroupId epgId = mock(EndpointGroupId.class);
List<EndpointGroupId> endpointGroups = Collections.singletonList(epgId);
when(endpoint.getEndpointGroups()).thenReturn(endpointGroups);
egKeys = manager.getEgKeysForEndpoint(endpoint);
- Assert.assertEquals(2, egKeys.size());
+ assertEquals(2, egKeys.size());
}
@Test
Endpoint endpoint = mock(Endpoint.class);
when(endpoint.getAugmentation(OfOverlayContext.class)).thenReturn(null);
// TODO
-// Assert.assertFalse(manager.isExternal(endpoint));
-// Assert.assertTrue(manager.isInternal(endpoint));
-//
-// OfOverlayContext ofc = mock(OfOverlayContext.class);
-// when(endpoint.getAugmentation(OfOverlayContext.class)).thenReturn(ofc);
-// when(ofc.getLocationType()).thenReturn(null);
-// Assert.assertFalse(manager.isExternal(endpoint));
-// Assert.assertTrue(manager.isInternal(endpoint));
-//
-// when(ofc.getLocationType()).thenReturn(LocationType.Internal);
-// Assert.assertFalse(manager.isExternal(endpoint));
-// Assert.assertTrue(manager.isInternal(endpoint));
-//
-// when(ofc.getLocationType()).thenReturn(LocationType.External);
-// Assert.assertTrue(manager.isExternal(endpoint));
-// Assert.assertFalse(manager.isInternal(endpoint));
+ // assertFalse(manager.isExternal(endpoint));
+ // assertTrue(manager.isInternal(endpoint));
+ //
+ // OfOverlayContext ofc = mock(OfOverlayContext.class);
+ // when(endpoint.getAugmentation(OfOverlayContext.class)).thenReturn(ofc);
+ // when(ofc.getLocationType()).thenReturn(null);
+ // assertFalse(manager.isExternal(endpoint));
+ // assertTrue(manager.isInternal(endpoint));
+ //
+ // when(ofc.getLocationType()).thenReturn(LocationType.Internal);
+ // assertFalse(manager.isExternal(endpoint));
+ // assertTrue(manager.isInternal(endpoint));
+ //
+ // when(ofc.getLocationType()).thenReturn(LocationType.External);
+ // assertTrue(manager.isExternal(endpoint));
+ // assertFalse(manager.isInternal(endpoint));
+ }
+
+ @Test
+ public void testGetL2EndpointFromL3() {
+ when(newL3Ep.getL2Context()).thenReturn(mock(L2BridgeDomainId.class));
+ when(newL3Ep.getMacAddress()).thenReturn(mock(MacAddress.class));
+
+ Endpoint ep = manager.getL2EndpointFromL3(newL3Ep);
+
+ assertNull(ep);
+ }
+
+ @Test
+ public void testGetL2EndpointFromL3_noL2Context_noMacAddr() {
+ when(newL3Ep.getL2Context()).thenReturn(null);
+ when(newL3Ep.getMacAddress()).thenReturn(null);
+
+ Endpoint ep = manager.getL2EndpointFromL3(newL3Ep);
+
+ assertNull(ep);
}
+
}
--- /dev/null
+/*\r
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint;\r
+\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.assertNull;\r
+import static org.mockito.Mockito.mock;\r
+import static org.mockito.Mockito.when;\r
+\r
+import java.util.ArrayList;\r
+import java.util.List;\r
+import java.util.Map;\r
+import java.util.concurrent.ExecutionException;\r
+\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;\r
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
+import org.opendaylight.groupbasedpolicy.api.EpRendererAugmentationRegistry;\r
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.test.TransactionMockUtils;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnectorBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Name;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.RegisterEndpointInput;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.RegisterEndpointInputBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.RegisterL3PrefixEndpointInput;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.RegisterL3PrefixEndpointInputBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.Endpoint;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Prefix;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayContextInput;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayContextInputBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodesBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;\r
+import org.opendaylight.yangtools.yang.binding.Augmentation;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
+\r
+public class OfOverlayAugTest {\r
+\r
+ private static final String PORT_NAME = "portName";\r
+ private DataBroker dataProvider;\r
+ private EpRendererAugmentationRegistry epRendererAugmentationRegistry;\r
+ private OfOverlayAug ofOverlayAug;\r
+\r
+ @Before\r
+ public void init() {\r
+ dataProvider = mock(DataBroker.class);\r
+ epRendererAugmentationRegistry = mock(EpRendererAugmentationRegistry.class);\r
+ ofOverlayAug = new OfOverlayAug(dataProvider, epRendererAugmentationRegistry);\r
+ }\r
+\r
+ @Test\r
+ public void testConstructor() throws Exception {\r
+ OfOverlayAug other = new OfOverlayAug(dataProvider, epRendererAugmentationRegistry);\r
+ other.close();\r
+ }\r
+\r
+ @SuppressWarnings("unchecked")\r
+ @Test\r
+ public void testBuildEndpointAugmentation() throws ExecutionException, InterruptedException {\r
+ Nodes nodes = buildNodes();\r
+\r
+ ReadOnlyTransaction roTx = mock(ReadOnlyTransaction.class);\r
+ TransactionMockUtils.setupRoTx(roTx, LogicalDatastoreType.OPERATIONAL,\r
+ InstanceIdentifier.builder(Nodes.class).build(), true, nodes);\r
+ when(dataProvider.newReadOnlyTransaction()).thenReturn(roTx);\r
+\r
+ OfOverlayContextInput contextInput =\r
+ new OfOverlayContextInputBuilder().setPortName(new Name(PORT_NAME)).build();\r
+\r
+ RegisterEndpointInput input =\r
+ new RegisterEndpointInputBuilder().addAugmentation(OfOverlayContextInput.class, contextInput).build();\r
+\r
+ Map.Entry<Class<? extends Augmentation<Endpoint>>, Augmentation<Endpoint>> entry =\r
+ ofOverlayAug.buildEndpointAugmentation(input);\r
+\r
+ assertNotNull(entry);\r
+ assertNotNull(entry.getValue());\r
+ }\r
+\r
+ @Test\r
+ public void testBuildEndpointAugmentation_null() {\r
+ RegisterEndpointInput input = new RegisterEndpointInputBuilder().build();\r
+\r
+ Map.Entry<Class<? extends Augmentation<Endpoint>>, Augmentation<Endpoint>> entry =\r
+ ofOverlayAug.buildEndpointAugmentation(input);\r
+\r
+ assertNull(entry);\r
+ }\r
+\r
+ @SuppressWarnings("unchecked")\r
+ @Test\r
+ public void testBuildEndpointL3Augmentation() throws ExecutionException, InterruptedException {\r
+ Nodes nodes = buildNodes();\r
+\r
+ ReadOnlyTransaction roTx = mock(ReadOnlyTransaction.class);\r
+ TransactionMockUtils.setupRoTx(roTx, LogicalDatastoreType.OPERATIONAL,\r
+ InstanceIdentifier.builder(Nodes.class).build(), true, nodes);\r
+ when(dataProvider.newReadOnlyTransaction()).thenReturn(roTx);\r
+\r
+ OfOverlayContextInput contextInput =\r
+ new OfOverlayContextInputBuilder().setPortName(new Name(PORT_NAME)).build();\r
+\r
+ RegisterEndpointInput input =\r
+ new RegisterEndpointInputBuilder().addAugmentation(OfOverlayContextInput.class, contextInput).build();\r
+\r
+ Map.Entry<Class<? extends Augmentation<EndpointL3>>, Augmentation<EndpointL3>> entry =\r
+ ofOverlayAug.buildEndpointL3Augmentation(input);\r
+\r
+ assertNotNull(entry);\r
+ assertNotNull(entry.getValue());\r
+ }\r
+\r
+ @Test\r
+ public void testBuildEndpointL3Augmentation_null() {\r
+ RegisterEndpointInput input = new RegisterEndpointInputBuilder().build();\r
+\r
+ Map.Entry<Class<? extends Augmentation<EndpointL3>>, Augmentation<EndpointL3>> entry =\r
+ ofOverlayAug.buildEndpointL3Augmentation(input);\r
+\r
+ assertNull(entry);\r
+ }\r
+\r
+ @Test\r
+ public void testBuildL3PrefixEndpointAugmentation() {\r
+ RegisterL3PrefixEndpointInput input = new RegisterL3PrefixEndpointInputBuilder().build();\r
+ Map.Entry<Class<? extends Augmentation<EndpointL3Prefix>>, Augmentation<EndpointL3Prefix>> entry =\r
+ ofOverlayAug.buildL3PrefixEndpointAugmentation(input);\r
+\r
+ // always returns null\r
+ assertNull(entry);\r
+ }\r
+\r
+ private Nodes buildNodes() {\r
+ FlowCapableNodeConnector fcnc = new FlowCapableNodeConnectorBuilder().setName(PORT_NAME).build();\r
+ NodeConnector nc = new NodeConnectorBuilder().addAugmentation(FlowCapableNodeConnector.class, fcnc).build();\r
+ List<NodeConnector> nodeConnectorList = new ArrayList<>();\r
+ nodeConnectorList.add(nc);\r
+ Node node = new NodeBuilder().setNodeConnector(nodeConnectorList).build();\r
+ List<Node> nodeList = new ArrayList<>();\r
+ nodeList.add(node);\r
+ return new NodesBuilder().setNode(nodeList).build();\r
+ }\r
+\r
+}\r
--- /dev/null
+/*
+ * Copyright (c) 2016 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.groupbasedpolicy.renderer.ofoverlay.endpoint;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.Set;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.util.concurrent.CheckedFuture;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.node.SwitchManager;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Name;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.Endpoints;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.Endpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayContext;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayContextBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class OfOverlayContextListenerTest {
+
+ private static final Name OLD_PORT_NAME = new Name("oldPort");
+ private static final Name NEW_PORT_NAME = new Name("newPort");
+ private OfOverlayContextListener listener;
+ private DataObjectModification<OfOverlayContext> rootNode;
+ private Set<DataTreeModification<OfOverlayContext>> changes;
+
+ private DataBroker dataProvider;
+ private SwitchManager switchManager;
+
+ private InstanceIdentifier<OfOverlayContext> rootIdentifier;
+ private OfOverlayContext oldContext;
+ private OfOverlayContext newContext;
+ private OfOverlayContext contextNoPortName;
+
+ @SuppressWarnings("unchecked")
+ @Before
+ public void init() {
+
+ dataProvider = mock(DataBroker.class);
+ switchManager = mock(SwitchManager.class);
+
+ NodeKey nodeKey = new NodeKey(new NodeId("nodeId"));
+ NodeConnectorKey nodeConnectorKey = new NodeConnectorKey(new NodeConnectorId("ncId"));
+ InstanceIdentifier<NodeConnector> ncIid = InstanceIdentifier.builder(Nodes.class)
+ .child(Node.class, nodeKey)
+ .child(NodeConnector.class, nodeConnectorKey)
+ .build();
+ when(switchManager.getNodeConnectorIidForPortName(NEW_PORT_NAME)).thenReturn(ncIid);
+
+ listener = spy(new OfOverlayContextListener(dataProvider, switchManager));
+ EndpointKey epKey = mock(EndpointKey.class);
+
+ rootNode = mock(DataObjectModification.class);
+ rootIdentifier = InstanceIdentifier.builder(Endpoints.class)
+ .child(Endpoint.class, epKey)
+ .augmentation(OfOverlayContext.class)
+ .build();
+ DataTreeIdentifier<OfOverlayContext> rootPath =
+ new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, rootIdentifier);
+
+ DataTreeModification<OfOverlayContext> change = mock(DataTreeModification.class);
+
+ when(change.getRootNode()).thenReturn(rootNode);
+ when(change.getRootPath()).thenReturn(rootPath);
+
+ changes = ImmutableSet.of(change);
+
+ oldContext = new OfOverlayContextBuilder().setPortName(OLD_PORT_NAME).build();
+ newContext = new OfOverlayContextBuilder().setPortName(NEW_PORT_NAME).build();
+ contextNoPortName = new OfOverlayContextBuilder().build();
+ }
+
+ @Test
+ public void testOnDataTreeChanged_Write() {
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.WRITE);
+ when(rootNode.getDataAfter()).thenReturn(newContext);
+
+ WriteTransaction wt = resetTransaction();
+
+ listener.onDataTreeChanged(changes);
+
+ verify(wt).merge(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class),
+ any(OfOverlayContext.class));
+ }
+
+ @Test
+ public void testOnDataTreeChanged_SubtreeModified() {
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED);
+ when(rootNode.getDataBefore()).thenReturn(oldContext);
+ when(rootNode.getDataAfter()).thenReturn(newContext);
+
+ WriteTransaction wt = resetTransaction();
+
+ listener.onDataTreeChanged(changes);
+
+ verify(wt).merge(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class),
+ any(OfOverlayContext.class));
+ }
+
+ @Test
+ public void testOnDataTreeChanged_SubtreeModified_bothNoPortName() {
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED);
+ when(rootNode.getDataBefore()).thenReturn(contextNoPortName);
+ when(rootNode.getDataAfter()).thenReturn(contextNoPortName);
+
+ WriteTransaction wt = resetTransaction();
+
+ listener.onDataTreeChanged(changes);
+
+ verify(wt, never()).merge(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class),
+ any(OfOverlayContext.class));
+ }
+
+ @Test
+ public void testOnDataTreeChanged_SubtreeModified_oneNoPortName() {
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED);
+ when(rootNode.getDataBefore()).thenReturn(oldContext);
+ when(rootNode.getDataAfter()).thenReturn(contextNoPortName);
+
+ WriteTransaction wt = resetTransaction();
+
+ listener.onDataTreeChanged(changes);
+
+ verify(wt, never()).merge(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class),
+ any(OfOverlayContext.class));
+ }
+
+ @Test
+ public void testOnDataTreeChanged_SubtreeModified_oneNoPortName1() {
+ when(switchManager.getNodeConnectorIidForPortName(NEW_PORT_NAME)).thenReturn(null);
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED);
+ when(rootNode.getDataBefore()).thenReturn(oldContext);
+ when(rootNode.getDataAfter()).thenReturn(newContext);
+
+ WriteTransaction wt = resetTransaction();
+
+ listener.onDataTreeChanged(changes);
+
+ verify(wt, never()).merge(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class),
+ any(OfOverlayContext.class));
+ }
+
+ @Test
+ public void testOnDataTreeChanged_SubtreeModified_samePortName() {
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED);
+ when(rootNode.getDataBefore()).thenReturn(newContext);
+ when(rootNode.getDataAfter()).thenReturn(newContext);
+
+ WriteTransaction wt = resetTransaction();
+
+ listener.onDataTreeChanged(changes);
+
+ verify(wt, never()).merge(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class),
+ any(OfOverlayContext.class));
+ }
+
+ @Test
+ public void testOnDataTreeChanged_Delete() {
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.DELETE);
+
+ WriteTransaction wt = resetTransaction();
+
+ listener.onDataTreeChanged(changes);
+
+ // no op
+ }
+
+ private WriteTransaction resetTransaction() {
+ WriteTransaction wt = mock(WriteTransaction.class);
+ CheckedFuture checkedFuture = mock(CheckedFuture.class);
+ when(wt.submit()).thenReturn(checkedFuture);
+ when(dataProvider.newWriteOnlyTransaction()).thenReturn(wt);
+ return wt;
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 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.groupbasedpolicy.renderer.ofoverlay.endpoint;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import java.util.Set;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.util.concurrent.CheckedFuture;
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.node.SwitchManager;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Name;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.Endpoints;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Key;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayContext;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayL3Context;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayL3ContextBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class OfOverlayL3ContextListenerTest {
+
+ private static final Name OLD_PORT_NAME = new Name("oldPort");
+ private static final Name NEW_PORT_NAME = new Name("newPort");
+ private OfOverlayL3ContextListener listener;
+ private DataObjectModification<OfOverlayL3Context> rootNode;
+ private Set<DataTreeModification<OfOverlayL3Context>> changes;
+
+ private DataBroker dataProvider;
+ private SwitchManager switchManager;
+
+ private InstanceIdentifier<OfOverlayL3Context> rootIdentifier;
+ private OfOverlayL3Context oldContext;
+ private OfOverlayL3Context newContext;
+ private OfOverlayL3Context contextNoPortName;
+
+ @SuppressWarnings("unchecked")
+ @Before
+ public void init() {
+
+ dataProvider = mock(DataBroker.class);
+ switchManager = mock(SwitchManager.class);
+
+ NodeKey nodeKey = new NodeKey(new NodeId("nodeId"));
+ NodeConnectorKey nodeConnectorKey = new NodeConnectorKey(new NodeConnectorId("ncId"));
+ InstanceIdentifier<NodeConnector> ncIid = InstanceIdentifier.builder(Nodes.class)
+ .child(Node.class, nodeKey)
+ .child(NodeConnector.class, nodeConnectorKey)
+ .build();
+ when(switchManager.getNodeConnectorIidForPortName(NEW_PORT_NAME)).thenReturn(ncIid);
+
+ listener = spy(new OfOverlayL3ContextListener(dataProvider, switchManager));
+ EndpointL3Key epL3Key = mock(EndpointL3Key.class);
+
+ rootNode = mock(DataObjectModification.class);
+ rootIdentifier = InstanceIdentifier.builder(Endpoints.class)
+ .child(EndpointL3.class, epL3Key)
+ .augmentation(OfOverlayL3Context.class)
+ .build();
+ DataTreeIdentifier<OfOverlayL3Context> rootPath =
+ new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, rootIdentifier);
+
+ DataTreeModification<OfOverlayL3Context> change = mock(DataTreeModification.class);
+
+ when(change.getRootNode()).thenReturn(rootNode);
+ when(change.getRootPath()).thenReturn(rootPath);
+
+ changes = ImmutableSet.of(change);
+
+ oldContext = new OfOverlayL3ContextBuilder().setPortName(OLD_PORT_NAME).build();
+ newContext = new OfOverlayL3ContextBuilder().setPortName(NEW_PORT_NAME).build();
+ contextNoPortName = new OfOverlayL3ContextBuilder().build();
+ }
+
+ @Test
+ public void testOnDataTreeChanged_Write() {
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.WRITE);
+ when(rootNode.getDataAfter()).thenReturn(newContext);
+
+ WriteTransaction wt = resetTransaction();
+
+ listener.onDataTreeChanged(changes);
+
+ verify(wt).merge(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class),
+ any(OfOverlayContext.class));
+ }
+
+ @Test
+ public void testOnDataTreeChanged_SubtreeModified() {
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED);
+ when(rootNode.getDataBefore()).thenReturn(oldContext);
+ when(rootNode.getDataAfter()).thenReturn(newContext);
+
+ WriteTransaction wt = resetTransaction();
+
+ listener.onDataTreeChanged(changes);
+
+ verify(wt).merge(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class),
+ any(OfOverlayContext.class));
+ }
+
+ @Test
+ public void testOnDataTreeChanged_SubtreeModified_bothNoPortName() {
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED);
+ when(rootNode.getDataBefore()).thenReturn(contextNoPortName);
+ when(rootNode.getDataAfter()).thenReturn(contextNoPortName);
+
+ WriteTransaction wt = resetTransaction();
+
+ listener.onDataTreeChanged(changes);
+
+ verify(wt, never()).merge(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class),
+ any(OfOverlayContext.class));
+ }
+
+ @Test
+ public void testOnDataTreeChanged_SubtreeModified_oneNoPortName() {
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED);
+ when(rootNode.getDataBefore()).thenReturn(oldContext);
+ when(rootNode.getDataAfter()).thenReturn(contextNoPortName);
+
+ WriteTransaction wt = resetTransaction();
+
+ listener.onDataTreeChanged(changes);
+
+ verify(wt, never()).merge(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class),
+ any(OfOverlayContext.class));
+ }
+
+ @Test
+ public void testOnDataTreeChanged_SubtreeModified_oneNoPortName1() {
+ when(switchManager.getNodeConnectorIidForPortName(NEW_PORT_NAME)).thenReturn(null);
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED);
+ when(rootNode.getDataBefore()).thenReturn(oldContext);
+ when(rootNode.getDataAfter()).thenReturn(newContext);
+
+ WriteTransaction wt = resetTransaction();
+
+ listener.onDataTreeChanged(changes);
+
+ verify(wt, never()).merge(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class),
+ any(OfOverlayContext.class));
+ }
+
+ @Test
+ public void testOnDataTreeChanged_SubtreeModified_samePortName() {
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.SUBTREE_MODIFIED);
+ when(rootNode.getDataBefore()).thenReturn(newContext);
+ when(rootNode.getDataAfter()).thenReturn(newContext);
+
+ WriteTransaction wt = resetTransaction();
+
+ listener.onDataTreeChanged(changes);
+
+ verify(wt, never()).merge(eq(LogicalDatastoreType.OPERATIONAL), any(InstanceIdentifier.class),
+ any(OfOverlayContext.class));
+ }
+
+ @Test
+ public void testOnDataTreeChanged_Delete() {
+ when(rootNode.getModificationType()).thenReturn(DataObjectModification.ModificationType.DELETE);
+
+ WriteTransaction wt = resetTransaction();
+
+ listener.onDataTreeChanged(changes);
+
+ // no op
+ }
+
+ private WriteTransaction resetTransaction() {
+ WriteTransaction wt = mock(WriteTransaction.class);
+ CheckedFuture checkedFuture = mock(CheckedFuture.class);
+ when(wt.submit()).thenReturn(checkedFuture);
+ when(dataProvider.newWriteOnlyTransaction()).thenReturn(wt);
+ return wt;
+ }
+
+}
--- /dev/null
+/*\r
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint;\r
+\r
+import static org.junit.Assert.assertNotNull;\r
+import static org.junit.Assert.assertNull;\r
+import static org.mockito.Mockito.mock;\r
+\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.groupbasedpolicy.api.EpRendererAugmentationRegistry;\r
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;\r
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.RegisterEndpointInput;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.RegisterEndpointInputBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.RegisterL3PrefixEndpointInput;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.RegisterL3PrefixEndpointInputBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.l3endpoint.rev151217.NatAddressInput;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.l3endpoint.rev151217.NatAddressInputBuilder;\r
+\r
+public class OfOverlayL3NatAugTest {\r
+\r
+ private OfOverlayL3NatAug ofOverlayL3NatAug;\r
+ private EpRendererAugmentationRegistry epRendererAugmentationRegistry;\r
+\r
+ @Before\r
+ public void init() {\r
+ epRendererAugmentationRegistry = mock(EpRendererAugmentationRegistry.class);\r
+ ofOverlayL3NatAug = new OfOverlayL3NatAug(epRendererAugmentationRegistry);\r
+ }\r
+\r
+ @Test\r
+ public void testConstructor() throws Exception {\r
+ OfOverlayL3NatAug other = new OfOverlayL3NatAug(epRendererAugmentationRegistry);\r
+ other.close();\r
+ }\r
+\r
+ @Test\r
+ public void testBuildEndpointAugmentation() {\r
+ RegisterEndpointInput input = new RegisterEndpointInputBuilder().build();\r
+ // no op\r
+ assertNull(ofOverlayL3NatAug.buildEndpointAugmentation(input));\r
+ }\r
+\r
+ @Test\r
+ public void testBuildEndpointL3Augmentation() {\r
+ NatAddressInput natAddressInput = new NatAddressInputBuilder().setNatAddress(\r
+ new IpAddress(new Ipv4Address("10.0.0.2"))).build();\r
+ RegisterEndpointInput input =\r
+ new RegisterEndpointInputBuilder().addAugmentation(NatAddressInput.class,\r
+ natAddressInput).build();\r
+ assertNotNull(ofOverlayL3NatAug.buildEndpointL3Augmentation(input));\r
+ }\r
+\r
+ @Test\r
+ public void testBuildEndpointL3Augmentation_noAug() {\r
+ RegisterEndpointInput input = new RegisterEndpointInputBuilder().build();\r
+ assertNull(ofOverlayL3NatAug.buildEndpointL3Augmentation(input));\r
+ }\r
+\r
+ @Test\r
+ public void testBuildL3PrefixEndpointAugmentation() {\r
+ RegisterL3PrefixEndpointInput input = new RegisterL3PrefixEndpointInputBuilder().build();\r
+ // no op\r
+\r
+ assertNull(ofOverlayL3NatAug.buildL3PrefixEndpointAugmentation(input));\r
+ }\r
+\r
+ @Test\r
+ public void testClose() {\r
+ // fail("Not yet implemented");\r
+ }\r
+\r
+}\r
--- /dev/null
+/*
+ * Copyright (c) 2016 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.groupbasedpolicy.renderer.ofoverlay.equivalence;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.Buckets;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.BucketsBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.GroupBuilder;
+
+public class BucketsEquivalenceTest {
+ BucketsEquivalence eq;
+
+ @Before
+ public void init() {
+ eq = new BucketsEquivalence();
+ }
+
+ @Test
+ public void testDoEquivalent() {
+ Buckets a = new BucketsBuilder().build();
+ Buckets b = new BucketsBuilder().build();
+ eq.doEquivalent(a, b);
+ }
+
+ @Test
+ public void testDoHash() {
+ Buckets a = new BucketsBuilder().build();
+ eq.doHash(a);
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 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.groupbasedpolicy.renderer.ofoverlay.equivalence;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.GroupBuilder;
+
+public class GroupEquivalenceTest {
+
+ GroupEquivalence eq;
+
+ @Before
+ public void init() {
+ eq = new GroupEquivalence();
+ }
+
+ @Test
+ public void testDoEquivalent() {
+ Group a = new GroupBuilder().build();
+ Group b = new GroupBuilder().build();
+ eq.doEquivalent(a, b);
+ }
+
+ @Test
+ public void testDoHash() {
+
+ Group a = new GroupBuilder().build();
+ eq.doHash(a);
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 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.groupbasedpolicy.renderer.ofoverlay.statistics;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import com.sun.jersey.api.client.ClientHandlerException;
+import com.sun.jersey.api.client.ClientResponse;
+import com.sun.jersey.api.client.UniformInterfaceException;
+import org.junit.Before;
+import org.junit.Test;
+
+public class JsonRestClientResponseTest {
+
+ private static final String STRING_ENTITY = "string entity";
+ private ClientResponse clientResponse;
+
+ @Before
+ public void init() {
+ clientResponse = mock(ClientResponse.class);
+
+ }
+
+ @Test
+ public void testResponse_Ok() {
+ when(clientResponse.getEntity(String.class)).thenReturn(STRING_ENTITY);
+ when(clientResponse.getStatus()).thenReturn(200);
+ JsonRestClientResponse response = new JsonRestClientResponse(clientResponse);
+
+ assertSame(clientResponse, response.getClientResponse());
+ assertEquals(STRING_ENTITY, response.getJsonResponse());
+ assertEquals(200, response.getStatusCode());
+ assertNull(response.getClientHandlerException());
+ }
+
+ @Test
+ public void testResponse_UniformInterfaceException() {
+ UniformInterfaceException ex = new UniformInterfaceException(clientResponse);
+ when(clientResponse.getEntity(String.class)).thenThrow(ex);
+ when(clientResponse.getStatus()).thenReturn(204);
+
+ JsonRestClientResponse response = new JsonRestClientResponse(clientResponse);
+
+ assertNull(response.getJsonResponse());
+ assertEquals(204, response.getStatusCode());
+ assertNull(response.getClientHandlerException());
+ }
+
+ @Test
+ public void testResponse_ClientHandlerException() {
+ ClientHandlerException ex = new ClientHandlerException();
+ when(clientResponse.getEntity(String.class)).thenThrow(ex);
+ when(clientResponse.getStatus()).thenReturn(404);
+
+ JsonRestClientResponse response = new JsonRestClientResponse(clientResponse);
+
+ assertNull(response.getJsonResponse());
+ assertEquals(404, response.getStatusCode());
+ assertSame(ex, response.getClientHandlerException());
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 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.groupbasedpolicy.renderer.ofoverlay.statistics;
+
+import static org.junit.Assert.assertEquals;
+
+import javax.ws.rs.Consumes;
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.core.Response;
+import java.io.IOException;
+
+import com.google.common.collect.ImmutableList;
+import com.sun.jersey.api.container.grizzly2.GrizzlyServerFactory;
+import com.sun.jersey.api.core.ClassNamesResourceConfig;
+import com.sun.jersey.api.core.ResourceConfig;
+import com.sun.jersey.core.util.MultivaluedMapImpl;
+import com.sun.jersey.test.framework.AppDescriptor;
+import com.sun.jersey.test.framework.JerseyTest;
+import com.sun.jersey.test.framework.WebAppDescriptor;
+import org.glassfish.grizzly.http.server.HttpServer;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.util.SFlowQueryParams;
+
+public class JsonRestClientTest extends JerseyTest {
+
+ private static final int CONNECT_TIMEOUT_MILLISEC = 20000;
+ private static final int READ_TIMEOUT_MILLISEC = 30000;
+ private static final String SFLOW_HOST = "localhost";
+ private static final int SFLOW_PORT = 1234;
+ private static HttpServer server;
+ private static final String SFLOW_URI = "http://" + SFLOW_HOST + ":" + SFLOW_PORT;
+
+ private JsonRestClient client;
+ private String uri;
+ private static String responseJson =
+ " { \"resolved-policy-uri\" : \"/restconf/operational/resolved-policy:resolved-policies/resolved-policy/tenant-red/client/tenant-red/webserver/\" } ";
+
+ private static HttpServer startServer() throws IOException {
+ final ResourceConfig resourceConfig = new ClassNamesResourceConfig(dumbServer.class);
+ HttpServer httpServer;
+ httpServer = GrizzlyServerFactory.createHttpServer(java.net.URI.create(SFLOW_URI), resourceConfig);
+ return httpServer;
+ }
+
+ @BeforeClass
+ public static void setUpClass() throws IOException {
+ server = startServer();
+ }
+
+ @AfterClass
+ public static void tearDownClass() {
+ if (server != null && server.isStarted())
+ server.stop();
+ }
+
+ @Before
+ public void init() {
+ client = new JsonRestClient(SFLOW_URI, CONNECT_TIMEOUT_MILLISEC, READ_TIMEOUT_MILLISEC);
+ }
+
+ @Test
+ public void testGetHost() {
+ String host = client.getHost();
+
+ assertEquals(SFLOW_HOST, host);
+ }
+
+ @Test
+ public void testGet_coverageOnly() {
+ client.get("/");
+ }
+
+ @Test
+ public void testGet_params_coverageOnly() {
+ MultivaluedMap<String, String> params = new MultivaluedMapImpl();
+ params.add(SFlowQueryParams.MAX_FLOWS, "20");
+ params.add(SFlowQueryParams.MIN_VALUE, "0.1");
+ params.add(SFlowQueryParams.AGG_MODE, "sum");
+
+ client.get("/", params);
+ }
+
+ @Test
+ public void testPost_coverageOnly() {
+ client.post("/", "json");
+ }
+
+ @Test
+ public void testPut_coverageOnly() {
+ client.put("/", "json");
+ }
+
+ @Test
+ public void testDelete_coverageOnly() {
+ client.delete("/");
+ }
+
+ @Override
+ protected AppDescriptor configure() {
+ return new WebAppDescriptor.Builder().build();
+ }
+
+ @Path("/")
+ public static class dumbServer {
+
+ @GET
+ @Produces(MediaType.APPLICATION_JSON)
+ public Response get200() {
+ return Response.status(Response.Status.OK).entity(responseJson).build();
+ }
+
+ @POST
+ @Consumes(MediaType.APPLICATION_JSON)
+ public Response post200(String json) {
+ return Response.status(Response.Status.OK).build();
+ }
+
+ }
+}
+/*\r
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics;\r
\r
import static org.mockito.Mockito.mock;\r
\r
+import java.util.Map;\r
import java.util.concurrent.ScheduledExecutorService;\r
\r
import org.junit.Before;\r
import org.junit.Test;\r
import org.opendaylight.groupbasedpolicy.api.StatisticsManager;\r
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.test.TestUtils;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.RuleName;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.SubjectName;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.Classifier;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.has.classifiers.ClassifierBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.resolved.policy.rev150828.resolved.policies.ResolvedPolicy;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
\r
public class OFStatisticsManagerTest {\r
\r
- ScheduledExecutorService executor;\r
- StatisticsManager statisticsManager;\r
+ private final EndpointGroupId consumerEpgId = new EndpointGroupId("consumerEpg1");\r
+ private final EndpointGroupId providerEpgId = new EndpointGroupId("providerEpg1");\r
+ private final ContractId contractId = new ContractId("contract1");\r
+ private final TenantId tenantId = new TenantId("tenant1");\r
+ private final ClassifierName classifierName = ClassifierName.getDefaultInstance("classifier1");\r
+ private final SubjectName subjectName = SubjectName.getDefaultInstance("subject1");\r
+ private final RuleName ruleName = new RuleName("rule1");\r
+\r
+ private InstanceIdentifier<ResolvedPolicy> rpIid;\r
+ private ResolvedPolicy resolvedPolicy;\r
+\r
+ private ScheduledExecutorService executor;\r
+ private StatisticsManager statisticsManager;\r
+\r
+ private OFStatisticsManager ofStatisticsManager;\r
+ private Classifier classifier;\r
+ private Map<InstanceIdentifier<Classifier>, Classifier> classifierByIid;\r
\r
@Before\r
public void init() {\r
executor = mock(ScheduledExecutorService.class);\r
statisticsManager = mock(StatisticsManager.class);\r
+\r
+ classifier = new ClassifierBuilder()\r
+ .setName(classifierName)\r
+ .build();\r
+ resolvedPolicy = TestUtils.newResolvedPolicy(tenantId, contractId, subjectName, ruleName,\r
+ consumerEpgId, providerEpgId, classifier);\r
+\r
+ rpIid = InstanceIdentifier.create(ResolvedPolicy.class);\r
+\r
+ ofStatisticsManager = new OFStatisticsManager(executor, statisticsManager);\r
+ ofStatisticsManager.setDelay(20L);\r
+ ofStatisticsManager.setSflowCollectorUri("http://localhost:1234");\r
+\r
+ classifierByIid =\r
+ ResolvedPolicyClassifierListener.resolveClassifiers(resolvedPolicy, rpIid);\r
}\r
\r
@Test\r
public void testConstructor() throws Exception {\r
- new OFStatisticsManager(executor, statisticsManager);\r
+ OFStatisticsManager other = new OFStatisticsManager(executor, statisticsManager);\r
+ other.close();\r
}\r
\r
+ @Test\r
+ public void testTTT(){\r
+ for (Map.Entry<InstanceIdentifier<Classifier>, Classifier> classifierEntry : classifierByIid.entrySet()) {\r
+ ofStatisticsManager.pullStatsForClassifier(classifierEntry.getKey(),\r
+ classifierEntry.getValue());\r
+ }\r
+ }\r
}\r
--- /dev/null
+/*
+ * Copyright (c) 2016 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.groupbasedpolicy.renderer.ofoverlay.statistics;
+
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.apache.commons.lang3.tuple.Pair;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.opendaylight.groupbasedpolicy.api.StatisticsManager;
+import org.opendaylight.groupbasedpolicy.dto.ConsEpgKey;
+import org.opendaylight.groupbasedpolicy.dto.EpgKeyDto;
+import org.opendaylight.groupbasedpolicy.dto.ProvEpgKey;
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.flowcache.FlowCache;
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.flowcache.FlowCacheData;
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.util.FlowCacheCons;
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.util.IidSflowNameUtil;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContractId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.TenantId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.endpoints.EndpointL3Builder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.HasDirection;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.EndpointGroup;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.EndpointGroupBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.statistics.rev151215.statistic.records.StatRecords;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+@RunWith(PowerMockRunner.class)
+@PrepareForTest({OFStatisticsManager.class, IidSflowNameUtil.class, OFStatisticsManager.class})
+public class ProcessDataTaskTest {
+
+ private final String IP_PROTO = "6";
+ private final String SRC_IP = "192.168.35.2";
+ private final String DST_IP = "192.168.36.2";
+ private final TenantId tenantId = new TenantId("tenantId");
+ private final EndpointGroupId srcEpgId = new EndpointGroupId("srcEpgId");
+ private final EndpointGroupId dstEpgId = new EndpointGroupId("dstEpgId");
+ private final ContractId contractId = new ContractId("contractId");
+ private final ClassifierName classifierName = new ClassifierName("classifierName");
+
+ private FlowCache flowCache;
+ private FlowCacheData data;
+ private ProcessDataTask task;
+
+ private EndpointL3 srcEpL3;
+ private EndpointL3 dstEpL3;
+ private EndpointGroup srcEpg;
+ private EndpointGroup dstEpg;
+
+ @Before
+ public void init() {
+ PowerMockito.mockStatic(OFStatisticsManager.class);
+ PowerMockito.mockStatic(IidSflowNameUtil.class);
+ PowerMockito.mockStatic(OFStatisticsManager.class);
+
+ String[] keyNames = {FlowCacheCons.Key.IP_PROTOCOL.get(), FlowCacheCons.Key.IP_SOURCE.get(),
+ FlowCacheCons.Key.IP_DESTINATION.get()};
+ flowCache = mock(FlowCache.class);
+ when(flowCache.getKeyNum()).thenReturn(3);
+ when(flowCache.getKeyNames()).thenReturn(keyNames);
+ when(flowCache.getName()).thenReturn("flowcache1");
+ when(flowCache.getDirection()).thenReturn(HasDirection.Direction.Out);
+ data = mock(FlowCacheData.class);
+ when(data.getKey()).thenReturn(IP_PROTO + "," + SRC_IP + "," + DST_IP);
+ List<FlowCacheData> dataList = new ArrayList<>();
+ dataList.add(data);
+ BigInteger timestamp = BigInteger.ZERO;
+ StatisticsManager statisticsManager = mock(StatisticsManager.class);
+ when(statisticsManager.writeStat(any(StatRecords.class))).thenReturn(true);
+
+ task = new ProcessDataTask(flowCache, dataList, timestamp, statisticsManager);
+
+ srcEpg = new EndpointGroupBuilder().setId(srcEpgId).build();
+ dstEpg = new EndpointGroupBuilder().setId(dstEpgId).build();
+ srcEpL3 = new EndpointL3Builder().setTenant(tenantId).setEndpointGroup(srcEpg.getId()).build();
+ dstEpL3 = new EndpointL3Builder().setTenant(tenantId).setEndpointGroup(dstEpg.getId()).build();
+ ConsEpgKey consEpgKey = new EpgKeyDto(srcEpg.getId(), tenantId);
+ ProvEpgKey provEpgKey = new EpgKeyDto(dstEpg.getId(), tenantId);
+ Pair<ConsEpgKey, ProvEpgKey> pair = Pair.of(consEpgKey, provEpgKey);
+ Set<Pair<ConsEpgKey, ProvEpgKey>> epgsForContract = new HashSet<>();
+ epgsForContract.add(pair);
+
+ when(OFStatisticsManager.getEpgsForContract(contractId)).thenReturn(epgsForContract);
+ }
+
+ @Test
+ public void testRun() {
+ when(OFStatisticsManager.getEndpointL3ForIp(SRC_IP)).thenReturn(srcEpL3);
+ when(OFStatisticsManager.getEndpointL3ForIp(DST_IP)).thenReturn(dstEpL3);
+ when(IidSflowNameUtil.resolveContractIdFromFlowCacheName(flowCache.getName())).thenReturn(contractId);
+ when(IidSflowNameUtil.resolveClassifierNameFromFlowCacheName(flowCache.getName())).thenReturn(classifierName);
+ when(IidSflowNameUtil.resolveFlowCacheValue(flowCache.getName())).thenReturn(FlowCacheCons.Value.BYTES.get());
+
+ task.run();
+ }
+
+ @Test
+ public void testRun_reversedConsProv() {
+ when(OFStatisticsManager.getEndpointL3ForIp(SRC_IP)).thenReturn(srcEpL3);
+ when(OFStatisticsManager.getEndpointL3ForIp(DST_IP)).thenReturn(dstEpL3);
+ when(IidSflowNameUtil.resolveContractIdFromFlowCacheName(flowCache.getName())).thenReturn(contractId);
+ when(IidSflowNameUtil.resolveClassifierNameFromFlowCacheName(flowCache.getName())).thenReturn(classifierName);
+ when(IidSflowNameUtil.resolveFlowCacheValue(flowCache.getName())).thenReturn(FlowCacheCons.Value.FRAMES.get());
+
+ ConsEpgKey consEpgKey = new EpgKeyDto(dstEpg.getId(), tenantId);
+ ProvEpgKey provEpgKey = new EpgKeyDto(srcEpg.getId(), tenantId);
+ Pair<ConsEpgKey, ProvEpgKey> pair = Pair.of(consEpgKey, provEpgKey);
+ Set<Pair<ConsEpgKey, ProvEpgKey>> epgsForContract = new HashSet<>();
+ epgsForContract.add(pair);
+ when(OFStatisticsManager.getEpgsForContract(contractId)).thenReturn(epgsForContract);
+
+ task.run();
+ }
+
+ @Test
+ public void testRun_noConsProv() {
+ when(OFStatisticsManager.getEndpointL3ForIp(SRC_IP)).thenReturn(srcEpL3);
+ when(OFStatisticsManager.getEndpointL3ForIp(DST_IP)).thenReturn(dstEpL3);
+ when(IidSflowNameUtil.resolveContractIdFromFlowCacheName(flowCache.getName())).thenReturn(contractId);
+ when(IidSflowNameUtil.resolveClassifierNameFromFlowCacheName(flowCache.getName())).thenReturn(classifierName);
+ when(IidSflowNameUtil.resolveFlowCacheValue(flowCache.getName())).thenReturn(FlowCacheCons.Value.FRAMES.get());
+
+ Set<Pair<ConsEpgKey, ProvEpgKey>> epgsForContract = new HashSet<>();
+ when(OFStatisticsManager.getEpgsForContract(contractId)).thenReturn(epgsForContract);
+
+ task.run();
+ }
+
+ @Test
+ public void testRun_wrongDataResponse() {
+ when(data.getKey()).thenReturn("1,2");
+ task.run();
+ }
+
+}
+/*\r
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics;\r
\r
import static org.mockito.Matchers.any;\r
-import static org.mockito.Matchers.anyMap;\r
-import static org.mockito.Matchers.anySet;\r
import static org.mockito.Matchers.anyString;\r
import static org.mockito.Mockito.doNothing;\r
import static org.mockito.Mockito.mock;\r
\r
import javax.ws.rs.core.MultivaluedMap;\r
\r
-import java.util.concurrent.ExecutorService;\r
import java.util.concurrent.ScheduledExecutorService;\r
\r
+import com.sun.jersey.api.client.ClientResponse;\r
import org.junit.Before;\r
import org.junit.Test;\r
+import org.mockito.Mockito;\r
import org.opendaylight.groupbasedpolicy.api.StatisticsManager;\r
\r
public class ReadGbpFlowCacheTaskTest {\r
\r
ReadGbpFlowCacheTask task;\r
+ private JsonRestClientResponse response;\r
\r
@Before\r
public void init() {\r
StatisticsManager statisticsManager = mock(StatisticsManager.class);\r
ScheduledExecutorService executor = mock(ScheduledExecutorService.class);\r
- JsonRestClientResponse response = mock(JsonRestClientResponse.class);\r
+ ClientResponse clientResponse = mock(ClientResponse.class);\r
+ response = mock(JsonRestClientResponse.class);\r
when(response.getJsonResponse()).thenReturn("[{\"one\":1, \"two\":2, \"three\":3}]");\r
when(response.getStatusCode()).thenReturn(200);\r
+ when(response.getClientResponse()).thenReturn(clientResponse);\r
SFlowRTConnection connection = mock(SFlowRTConnection.class);\r
- when(connection.get(anyString(), any(MultivaluedMap.class))).thenReturn(response);\r
+ when(connection.get(anyString(), Mockito.<MultivaluedMap<String, String>>any())).thenReturn(response);\r
when(connection.getExecutor()).thenReturn(executor);\r
doNothing().when(executor).execute(any(Runnable.class));\r
\r
\r
@Test\r
public void testRun() {\r
+ task.run();\r
+ }\r
+\r
+ @Test\r
+ public void testRun_response300() {\r
+ when(response.getStatusCode()).thenReturn(300);\r
+ task.run();\r
+ }\r
\r
+ @Test\r
+ public void testRun_response400() {\r
+ when(response.getStatusCode()).thenReturn(400);\r
task.run();\r
}\r
\r
+/*\r
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics;\r
\r
import static org.mockito.Mockito.mock;\r
--- /dev/null
+/*
+ * Copyright (c) 2016 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.groupbasedpolicy.renderer.ofoverlay.statistics;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+import javax.ws.rs.core.MultivaluedMap;
+import java.util.concurrent.ScheduledExecutorService;
+
+import com.sun.jersey.api.client.ClientHandlerException;
+import com.sun.jersey.core.util.MultivaluedMapImpl;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.mockito.Mockito;
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.flowcache.FlowCache;
+import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.util.SFlowQueryParams;
+
+public class SFlowRTConnectionTest {
+
+ private static final String PATH = "/";
+ private static final String JSON_STRING = "jsonString";
+ private static final String JSON_RESPONSE = "jsonResponse";
+
+ private ScheduledExecutorService executor;
+ private String collectorUri;
+ private FlowCache flowCache;
+ private JsonRestClient client;
+ private MultivaluedMap<String, String> params;
+ private SFlowRTConnection connection;
+ private JsonRestClientResponse response;
+
+ @Rule
+ public ExpectedException thrown = ExpectedException.none();
+
+ @Before
+ public void init() {
+ params = new MultivaluedMapImpl();
+ params.add(SFlowQueryParams.MAX_FLOWS, "20");
+ params.add(SFlowQueryParams.MIN_VALUE, "0.1");
+ params.add(SFlowQueryParams.AGG_MODE, "sum");
+
+ executor = mock(ScheduledExecutorService.class);
+ collectorUri = "";
+ flowCache = mock(FlowCache.class);
+ client = mock(JsonRestClient.class);
+ response = mock(JsonRestClientResponse.class);
+ when(response.getJsonResponse()).thenReturn(JSON_RESPONSE);
+ when(response.getStatusCode()).thenReturn(200);
+ when(client.get(any(String.class), Mockito.<MultivaluedMap<String, String>>any())).thenReturn(response);
+ when(client.put(any(String.class), any(String.class))).thenReturn(response);
+ when(client.delete(any(String.class))).thenReturn(response);
+
+ connection = spy(new SFlowRTConnection(executor, collectorUri, flowCache, client));
+ }
+
+ @Test
+ public void testConstructor() {
+ SFlowRTConnection other = new SFlowRTConnection(executor, collectorUri, flowCache, client);
+
+ assertNotNull(other.getExecutor());
+ assertNotNull(other.getFlowCache());
+ }
+
+ @Test
+ public void testGetJsonResponse() {
+ String res = connection.getJsonResponse(PATH, params);
+
+ assertEquals(JSON_RESPONSE, res);
+ }
+
+ @Test(expected = ClientHandlerException.class)
+ public void testGetJsonResponse_ClientHandlerException_noCause() {
+ ClientHandlerException ex = new ClientHandlerException();
+ when(client.get(any(String.class), Mockito.<MultivaluedMap<String, String>>any())).thenThrow(ex);
+
+ connection.getJsonResponse(PATH, params);
+ }
+
+ @Test(expected = ClientHandlerException.class)
+ public void testGetJsonResponse_ClientHandlerException_caused() {
+ ClientHandlerException ex = new ClientHandlerException();
+ ex.initCause(new java.net.ConnectException());
+ when(client.get(any(String.class), Mockito.<MultivaluedMap<String, String>>any())).thenThrow(ex);
+
+ connection.getJsonResponse(PATH, params);
+ }
+
+ @Test
+ public void testGet() {
+ JsonRestClientResponse res = connection.get(PATH, params);
+
+ assertEquals(response, res);
+ }
+
+ @Test
+ public void testGet_notInitialized() {
+ when(connection.isInitialized()).thenReturn(false);
+
+ thrown.expect(IllegalStateException.class);
+ thrown.expectMessage(SFlowRTConnection.EX_MSG_NOT_INITIALIZED);
+ connection.get(PATH, params);
+ }
+
+ @Test(expected = ClientHandlerException.class)
+ public void testGet_ClientHandlerException_noCause() {
+ ClientHandlerException ex = new ClientHandlerException();
+ when(client.get(any(String.class), Mockito.<MultivaluedMap<String, String>>any())).thenThrow(ex);
+
+ connection.get(PATH, params);
+ }
+
+ @Test(expected = ClientHandlerException.class)
+ public void testGet_ClientHandlerException_caused() {
+ ClientHandlerException ex = new ClientHandlerException();
+ ex.initCause(new java.net.ConnectException());
+ when(client.get(any(String.class), Mockito.<MultivaluedMap<String, String>>any())).thenThrow(ex);
+
+ connection.get(PATH, params);
+ }
+
+ @Test
+ public void testPut() {
+ JsonRestClientResponse res = connection.put(PATH, JSON_STRING);
+
+ assertEquals(response, res);
+ }
+
+ @Test
+ public void testPut_notInitialized() {
+ when(connection.isInitialized()).thenReturn(false);
+
+ thrown.expect(IllegalStateException.class);
+ thrown.expectMessage(SFlowRTConnection.EX_MSG_NOT_INITIALIZED);
+ connection.put(PATH, JSON_STRING);
+ }
+
+ @Test(expected = ClientHandlerException.class)
+ public void testPut_ClientHandlerException_noCause() {
+ ClientHandlerException ex = new ClientHandlerException();
+ when(client.put(any(String.class), any(String.class))).thenThrow(ex);
+
+ connection.put(PATH, JSON_STRING);
+ }
+
+ @Test(expected = ClientHandlerException.class)
+ public void testPut_ClientHandlerException_caused() {
+ ClientHandlerException ex = new ClientHandlerException();
+ ex.initCause(new java.net.ConnectException());
+ when(client.put(any(String.class), any(String.class))).thenThrow(ex);
+
+ connection.put(PATH, JSON_STRING);
+ }
+
+ @Test
+ public void testDelete() {
+ JsonRestClientResponse res = connection.delete(PATH);
+
+ assertEquals(response, res);
+ }
+
+ @Test
+ public void testDelete_notInitialized() {
+ when(connection.isInitialized()).thenReturn(false);
+
+ thrown.expect(IllegalStateException.class);
+ thrown.expectMessage(SFlowRTConnection.EX_MSG_NOT_INITIALIZED);
+ connection.delete(PATH);
+ }
+
+ @Test(expected = ClientHandlerException.class)
+ public void testDelete_ClientHandlerException_noCause() {
+ ClientHandlerException ex = new ClientHandlerException();
+ when(client.delete(any(String.class))).thenThrow(ex);
+
+ connection.delete(PATH);
+ }
+
+ @Test(expected = ClientHandlerException.class)
+ public void testDelete_ClientHandlerException_caused() {
+ ClientHandlerException ex = new ClientHandlerException();
+ ex.initCause(new java.net.ConnectException());
+ when(client.delete(any(String.class))).thenThrow(ex);
+
+ connection.delete(PATH);
+ }
+
+ @Test
+ public void testInitialize() {
+ when(response.getStatusCode()).thenReturn(300);
+ connection.initialize();
+ assertTrue(connection.isInitialized());
+
+ when(response.getStatusCode()).thenReturn(400);
+ connection.initialize();
+ assertTrue(connection.isInitialized());
+ }
+
+ @Test
+ public void testLogStatusCode_coverage() {
+ when(response.getStatusCode()).thenReturn(300);
+ connection.getJsonResponse(PATH, params);
+ connection.delete(PATH);
+
+ when(response.getStatusCode()).thenReturn(400);
+ connection.getJsonResponse(PATH, params);
+ connection.delete(PATH);
+ }
+
+}
+/*\r
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics;\r
\r
import static org.mockito.Mockito.mock;\r
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.ofoverlay.test;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.util.concurrent.ExecutionException;
+
+import com.google.common.base.Optional;
+import com.google.common.util.concurrent.CheckedFuture;
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class TransactionMockUtils {
+
+ /**
+ * Stubs {@link ReadOnlyTransaction#read(LogicalDatastoreType, InstanceIdentifier)}
+ * to return a given {@link DataObject}
+ *
+ * @param roTx mocked transaction to stub
+ * @param store {@link LogicalDatastoreType}
+ * @param path {@link InstanceIdentifier}
+ * @param isPresent stub {@link Optional#isPresent()}; if {@code true}, stub
+ * {@link Optional#get()} to return {@code returnObject}
+ * @param returnObject {@link DataObject} to return
+ * @param <T> type of {@code returnObject}
+ * @throws ExecutionException
+ * @throws InterruptedException
+ */
+ @SuppressWarnings("unchecked")
+ public static <T extends DataObject> void setupRoTx(ReadOnlyTransaction roTx, LogicalDatastoreType store,
+ InstanceIdentifier<T> path, boolean isPresent, T returnObject)
+ throws ExecutionException, InterruptedException {
+
+ CheckedFuture<Optional<T>, ReadFailedException> future = mock(CheckedFuture.class);
+ when(roTx.read(store, path)).thenReturn(future);
+ Optional<T> opt = mock(Optional.class);
+ when(future.get()).thenReturn(opt);
+ when(opt.isPresent()).thenReturn(isPresent);
+ if (isPresent) {
+ when(opt.get()).thenReturn(returnObject);
+ }
+ }
+
+}
<artifactId>vpp-renderer</artifactId>
<packaging>bundle</packaging>
- <properties></properties>
+ <properties>
+ <netconf.version>1.1.0-SNAPSHOT</netconf.version>
+ </properties>
+
+ <dependencyManagement>
+ <dependencies>
+ <dependency>
+ <groupId>org.opendaylight.netconf</groupId>
+ <artifactId>netconf-artifacts</artifactId>
+ <version>${netconf.version}</version>
+ <type>pom</type>
+ <scope>import</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>mdsal-artifacts</artifactId>
+ <version>${mdsal.version}</version>
+ <type>pom</type>
+ <scope>import</scope>
+ </dependency>
+ </dependencies>
+ </dependencyManagement>
<dependencies>
<!-- project specific dependencies -->
+ <dependency>
+ <groupId>org.opendaylight.mdsal.model</groupId>
+ <artifactId>ietf-yang-types-20130715</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal.model</groupId>
+ <artifactId>ietf-inet-types-2013-07-15</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal.model</groupId>
+ <artifactId>yang-ext</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal.model</groupId>
+ <artifactId>iana-if-type-2014-05-08</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.mdsal.model</groupId>
+ <artifactId>ietf-interfaces</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.netconf</groupId>
+ <artifactId>sal-netconf-connector</artifactId>
+ </dependency>
<!-- testing dependencies -->
+ <dependency>
+ <groupId>org.opendaylight.controller</groupId>
+ <artifactId>sal-binding-broker-impl</artifactId>
+ <type>test-jar</type>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.opendaylight.groupbasedpolicy</groupId>
+ <artifactId>groupbasedpolicy</artifactId>
+ <version>${project.version}</version>
+ <type>test-jar</type>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<configuration>
<instructions>
<Export-Package>
- org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp.input.rev160425.*
- </Export-Package> -->
+ org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.*
+ </Export-Package>
</instructions>
</configuration>
</plugin>
<type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">binding:binding-async-data-broker</type>
<name>binding-data-broker</name>
</data-broker>
+ <broker>
+ <type xmlns:binding="urn:opendaylight:params:xml:ns:yang:controller:md:sal:binding">binding:binding-broker-osgi-registry</type>
+ <name>binding-osgi-broker</name>
+ </broker>
</module>
</modules>
</data>
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class VppProviderModule extends org.opendaylight.controller.config.yang.config.vpp_provider.impl.AbstractVppProviderModule {
+public class GbpVppProviderModule extends org.opendaylight.controller.config.yang.config.vpp_provider.impl.AbstractGbpVppProviderModule {
- private static final Logger LOG = LoggerFactory.getLogger(VppProviderModule.class);
+ private static final Logger LOG = LoggerFactory.getLogger(GbpVppProviderModule.class);
- public VppProviderModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) {
+ public GbpVppProviderModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) {
super(identifier, dependencyResolver);
}
- public VppProviderModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver, org.opendaylight.controller.config.yang.config.vpp_provider.impl.VppProviderModule oldModule, java.lang.AutoCloseable oldInstance) {
+ public GbpVppProviderModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver, org.opendaylight.controller.config.yang.config.vpp_provider.impl.GbpVppProviderModule oldModule, java.lang.AutoCloseable oldInstance) {
super(identifier, dependencyResolver, oldModule, oldInstance);
}
@Override
public java.lang.AutoCloseable createInstance() {
- final VppRenderer vppRenderer = new VppRenderer(getDataBrokerDependency());
+ final VppRenderer vppRenderer = new VppRenderer(getDataBrokerDependency(), getBrokerDependency());
LOG.info("VPP Renderer instance has been created");
*
* Generated from: yang module name: vpp-provider-impl yang module local name: vpp-provider-impl
* Generated by: org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator
-* Generated at: Thu May 05 09:46:48 CEST 2016
+* Generated at: Wed May 25 17:25:43 CEST 2016
*
* Do not modify this file unless it is present under src/main directory
*/
package org.opendaylight.controller.config.yang.config.vpp_provider.impl;
-public class VppProviderModuleFactory extends org.opendaylight.controller.config.yang.config.vpp_provider.impl.AbstractVppProviderModuleFactory {
+public class GbpVppProviderModuleFactory extends org.opendaylight.controller.config.yang.config.vpp_provider.impl.AbstractGbpVppProviderModuleFactory {
}
-/*\r
- * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.\r
- *\r
- * This program and the accompanying materials are made available under the\r
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
- * and is available at http://www.eclipse.org/legal/epl-v10.html\r
- */\r
-\r
-package org.opendaylight.controller.config.yang.config.vpp_provider.impl;\r
-\r
-import com.google.common.base.Preconditions;\r
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
-import org.slf4j.Logger;\r
-import org.slf4j.LoggerFactory;\r
-\r
-public class VppRenderer implements AutoCloseable {\r
- private static final Logger LOG = LoggerFactory.getLogger(VppRenderer.class);\r
-\r
- private DataBroker dataBroker;\r
-\r
- public VppRenderer(DataBroker dataBroker) {\r
- Preconditions.checkNotNull(dataBroker);\r
-\r
- this.dataBroker = dataBroker;\r
-\r
- LOG.info("VPP Renderer has Started");\r
- }\r
-\r
- @Override\r
- public void close() throws Exception {\r
- this.dataBroker = null;\r
- }\r
-\r
-}\r
+/*
+ * Copyright (c) 2016 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.config.vpp_provider.impl;
+
+import java.util.List;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.MountPointService;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
+import org.opendaylight.controller.sal.binding.api.BindingAwareProvider;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.iface.InterfaceManager;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.listener.VppEndpointListener;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.listener.VppNodeListener;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.manager.VppNodeManager;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.sf.AllowAction;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.sf.EtherTypeClassifier;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.util.MountedDataBrokerProvider;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.Renderer;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.RendererBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.RendererKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.CapabilitiesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererNodesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.SupportedActionDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.SupportedActionDefinitionBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.SupportedClassifierDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.SupportedClassifierDefinitionBuilder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+import com.google.common.eventbus.EventBus;
+import com.google.common.util.concurrent.CheckedFuture;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+
+public class VppRenderer implements AutoCloseable, BindingAwareProvider {
+
+ private static final Logger LOG = LoggerFactory.getLogger(VppRenderer.class);
+
+ private final List<SupportedActionDefinition> actionDefinitions =
+ ImmutableList.of(new SupportedActionDefinitionBuilder().setActionDefinitionId(new AllowAction().getId())
+ .setSupportedParameterValues(new AllowAction().getSupportedParameterValues())
+ .build());
+ private final List<SupportedClassifierDefinition> classifierDefinitions = ImmutableList
+ .of(new SupportedClassifierDefinitionBuilder().setClassifierDefinitionId(new EtherTypeClassifier(null).getId())
+ .setSupportedParameterValues(new EtherTypeClassifier(null).getSupportedParameterValues())
+ .build());
+
+ private final DataBroker dataBroker;
+
+ private VppNodeManager vppNodeManager;
+ private InterfaceManager interfaceManager;
+
+ private VppNodeListener vppNodeListener;
+ private VppEndpointListener vppEndpointListener;
+
+ public VppRenderer(DataBroker dataBroker, BindingAwareBroker bindingAwareBroker) {
+ this.dataBroker = Preconditions.checkNotNull(dataBroker);
+ bindingAwareBroker.registerProvider(this);
+ }
+
+ @Override
+ public void close() throws Exception {
+ LOG.info("Closing Vpp renderer");
+ if (vppNodeListener != null) {
+ vppNodeListener.close();
+ }
+ if (vppEndpointListener != null) {
+ vppEndpointListener.close();
+ }
+ if (interfaceManager != null) {
+ interfaceManager.close();
+ }
+ unregisterFromRendererManager();
+ }
+
+ @Override
+ public void onSessionInitiated(BindingAwareBroker.ProviderContext providerContext) {
+ LOG.info("starting vpp renderer");
+
+ MountPointService mountService = Preconditions.checkNotNull(providerContext.getSALService(MountPointService.class));
+ MountedDataBrokerProvider mountDataProvider = new MountedDataBrokerProvider(mountService);
+ vppNodeManager = new VppNodeManager(dataBroker, providerContext);
+
+ EventBus dtoEventBus = new EventBus("DTO events");
+ interfaceManager = new InterfaceManager(mountDataProvider, dataBroker);
+ dtoEventBus.register(interfaceManager);
+
+ vppNodeListener = new VppNodeListener(dataBroker, vppNodeManager, dtoEventBus);
+ vppEndpointListener = new VppEndpointListener(dataBroker, dtoEventBus);
+
+ registerToRendererManager();
+ }
+
+ private void registerToRendererManager() {
+ WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
+
+ Renderer renderer = new RendererBuilder().setName(VppNodeManager.vppRenderer)
+ .setRendererNodes(new RendererNodesBuilder().build())
+ .setCapabilities(new CapabilitiesBuilder().setSupportedActionDefinition(actionDefinitions)
+ .setSupportedClassifierDefinition(classifierDefinitions)
+ .build())
+ .build();
+
+ writeTransaction.put(LogicalDatastoreType.OPERATIONAL, VppIidFactory.getRendererIID(renderer.getKey()),
+ renderer, true);
+ CheckedFuture<Void, TransactionCommitFailedException> future = writeTransaction.submit();
+ Futures.addCallback(future, new FutureCallback<Void>() {
+
+ @Override
+ public void onFailure(Throwable throwable) {
+ LOG.error("Could not register renderer {}: {}", renderer, throwable);
+ }
+
+ @Override
+ public void onSuccess(Void result) {
+ LOG.debug("Renderer {} successfully registered.", renderer);
+ }
+ });
+ }
+
+
+ private void unregisterFromRendererManager() {
+ WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
+ writeTransaction.delete(LogicalDatastoreType.OPERATIONAL, VppIidFactory.getRendererIID(new RendererKey(VppNodeManager.vppRenderer)));
+
+ CheckedFuture<Void, TransactionCommitFailedException> future = writeTransaction.submit();
+ Futures.addCallback(future, new FutureCallback<Void>() {
+
+ @Override
+ public void onFailure(Throwable throwable) {
+ LOG.error("Could not unregister renderer {}: {}", VppNodeManager.vppRenderer, throwable);
+ }
+
+ @Override
+ public void onSuccess(Void result) {
+ LOG.debug("Renderer {} successfully unregistered.", VppNodeManager.vppRenderer);
+ }
+ });
+ }
+}
--- /dev/null
+/*\r
+ * Copyright (c) 2016 Cisco Systems. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
+package org.opendaylight.groupbasedpolicy.renderer.vpp.commands;\r
+\r
+import org.opendaylight.groupbasedpolicy.renderer.vpp.util.General;\r
+\r
+public abstract class AbstractInterfaceCommand<T extends AbstractInterfaceCommand<T>> implements ConfigCommand {\r
+\r
+ protected General.Operations operation;\r
+ protected String name;\r
+ protected String description;\r
+ protected Boolean enabled;\r
+\r
+ protected enum linkUpDownTrap {\r
+ ENABLED, DISABLED\r
+ }\r
+\r
+ public General.Operations getOperation() {\r
+ return operation;\r
+ }\r
+\r
+ public String getName() {\r
+ return name;\r
+ }\r
+\r
+ public String getDescription() {\r
+ return description;\r
+ }\r
+\r
+ public AbstractInterfaceCommand<T> setDescription(String description) {\r
+ this.description = description;\r
+ return this;\r
+ }\r
+\r
+ public Boolean getEnabled() {\r
+ return enabled;\r
+ }\r
+\r
+ public AbstractInterfaceCommand<T> setEnabled(Boolean enabled) {\r
+ this.enabled = enabled;\r
+ return this;\r
+ }\r
+\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2016 Cisco Systems. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
+package org.opendaylight.groupbasedpolicy.renderer.vpp.commands;\r
+\r
+import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;\r
+\r
+public interface ConfigCommand {\r
+\r
+ /**\r
+ * Execute command using a given data modification transaction\r
+ *\r
+ * @param readWriteTransaction Transaction for command execution\r
+ */\r
+ void execute(ReadWriteTransaction readWriteTransaction);\r
+\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2016 Cisco Systems. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
+package org.opendaylight.groupbasedpolicy.renderer.vpp.commands;\r
+\r
+import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;\r
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
+import org.opendaylight.groupbasedpolicy.renderer.vpp.util.General;\r
+import org.opendaylight.groupbasedpolicy.renderer.vpp.util.General.Operations;\r
+import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory;\r
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;\r
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VhostUserRole;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VppInterfaceAugmentation;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VppInterfaceAugmentationBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.interfaces._interface.L2Builder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.interfaces._interface.VhostUserBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.l2.attributes.interconnection.BridgeBasedBuilder;\r
+import org.slf4j.Logger;\r
+import org.slf4j.LoggerFactory;\r
+\r
+import com.google.common.base.Preconditions;\r
+import com.google.common.base.Strings;\r
+\r
+public class VhostUserCommand extends AbstractInterfaceCommand<VhostUserCommand> {\r
+\r
+ private static final Logger LOG = LoggerFactory.getLogger(VhostUserCommand.class);\r
+ private String socket;\r
+ private VhostUserRole role;\r
+ private String bridgeDomain;\r
+\r
+ private VhostUserCommand(VhostUserCommandBuilder builder) {\r
+ this.name = builder.getName();\r
+ this.operation = builder.getOperation();\r
+ this.socket = builder.getSocket();\r
+ this.role = builder.getRole();\r
+ this.enabled = builder.isEnabled();\r
+ this.description = builder.getDescription();\r
+ this.bridgeDomain = builder.getBridgeDomain();\r
+\r
+ }\r
+\r
+ public static VhostUserCommandBuilder builder() {\r
+ return new VhostUserCommandBuilder();\r
+ }\r
+\r
+ public String getSocket() {\r
+ return socket;\r
+ }\r
+\r
+ public VhostUserRole getRole() {\r
+ return role;\r
+ }\r
+\r
+ public String getBridgeDomain() {\r
+ return bridgeDomain;\r
+ }\r
+\r
+ @Override\r
+ public void execute(ReadWriteTransaction readWriteTransaction) {\r
+ switch (getOperation()) {\r
+\r
+ case PUT:\r
+ LOG.debug("Executing Add operation for command: {}", this);\r
+ put(readWriteTransaction);\r
+ break;\r
+ case DELETE:\r
+ LOG.debug("Executing Delete operation for command: {}", this);\r
+ delete(readWriteTransaction);\r
+ break;\r
+ case MERGE:\r
+ LOG.debug("Executing Update operation for command: {}", this);\r
+ merge(readWriteTransaction);\r
+ break;\r
+ default:\r
+ LOG.error("Execution failed for command: {}", this);\r
+ break;\r
+ }\r
+ }\r
+\r
+ private void put(ReadWriteTransaction readWriteTransaction) {\r
+ InterfaceBuilder interfaceBuilder = getVhostUserInterfaceBuilder();\r
+\r
+ readWriteTransaction.put(LogicalDatastoreType.CONFIGURATION,\r
+ VppIidFactory.getInterfaceIID(interfaceBuilder.getKey()), interfaceBuilder.build(), true);\r
+ }\r
+\r
+ private void merge(ReadWriteTransaction readWriteTransaction) {\r
+ InterfaceBuilder interfaceBuilder = getVhostUserInterfaceBuilder();\r
+\r
+ readWriteTransaction.merge(LogicalDatastoreType.CONFIGURATION,\r
+ VppIidFactory.getInterfaceIID(interfaceBuilder.getKey()), interfaceBuilder.build());\r
+ }\r
+\r
+ private InterfaceBuilder getVhostUserInterfaceBuilder() {\r
+ InterfaceBuilder interfaceBuilder =\r
+ new InterfaceBuilder().setKey(new InterfaceKey(name))\r
+ .setEnabled(enabled)\r
+ .setDescription(description)\r
+ .setType(\r
+ org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VhostUser.class)\r
+ .setName(name)\r
+ .setLinkUpDownTrapEnable(Interface.LinkUpDownTrapEnable.Enabled);\r
+\r
+ // Create the vhost augmentation\r
+ VppInterfaceAugmentationBuilder vppAugmentationBuilder = new VppInterfaceAugmentationBuilder()\r
+ .setVhostUser(new VhostUserBuilder().setRole(role).setSocket(socket).build());\r
+ if (!Strings.isNullOrEmpty(bridgeDomain)) {\r
+ vppAugmentationBuilder.setL2(new L2Builder()\r
+ .setInterconnection(new BridgeBasedBuilder().setBridgeDomain(bridgeDomain).build()).build());\r
+ }\r
+\r
+ interfaceBuilder.addAugmentation(VppInterfaceAugmentation.class, vppAugmentationBuilder.build());\r
+ return interfaceBuilder;\r
+ }\r
+\r
+ private void delete(ReadWriteTransaction readWriteTransaction) {\r
+ try {\r
+ readWriteTransaction.delete(LogicalDatastoreType.CONFIGURATION,\r
+ VppIidFactory.getInterfaceIID(new InterfaceKey(name)));\r
+ } catch (IllegalStateException ex) {\r
+ LOG.debug("Vhost Interface is not present in DS", ex);\r
+ }\r
+\r
+ }\r
+\r
+ @Override\r
+ public String toString() {\r
+ return "VhostUserCommand [socket=" + socket + ", role=" + role + ", bridgeDomain=" + bridgeDomain\r
+ + ", operation=" + operation + ", name=" + name + ", description=" + description + ", enabled="\r
+ + enabled + "]";\r
+ }\r
+\r
+\r
+\r
+ public static class VhostUserCommandBuilder {\r
+\r
+ private String name;\r
+ private General.Operations operation;\r
+ private String socket;\r
+ private VhostUserRole role = VhostUserRole.Server;\r
+ private boolean enabled = true;\r
+ private String description;\r
+ private String bridgeDomain;\r
+\r
+ public String getName() {\r
+ return name;\r
+ }\r
+\r
+ public VhostUserCommandBuilder setName(String name) {\r
+ this.name = name;\r
+ return this;\r
+ }\r
+\r
+ public General.Operations getOperation() {\r
+ return operation;\r
+ }\r
+\r
+ public VhostUserCommandBuilder setOperation(General.Operations operation) {\r
+ this.operation = operation;\r
+ return this;\r
+ }\r
+\r
+ public String getSocket() {\r
+ return socket;\r
+ }\r
+\r
+ public VhostUserCommandBuilder setSocket(String socket) {\r
+ this.socket = socket;\r
+ return this;\r
+ }\r
+\r
+ public VhostUserRole getRole() {\r
+ return role;\r
+ }\r
+\r
+ public VhostUserCommandBuilder setRole(VhostUserRole role) {\r
+ this.role = role;\r
+ return this;\r
+ }\r
+\r
+ public boolean isEnabled() {\r
+ return enabled;\r
+ }\r
+\r
+ public VhostUserCommandBuilder setEnabled(boolean enabled) {\r
+ this.enabled = enabled;\r
+ return this;\r
+ }\r
+\r
+ public String getDescription() {\r
+ return description;\r
+ }\r
+\r
+ public VhostUserCommandBuilder setDescription(String description) {\r
+ this.description = description;\r
+ return this;\r
+ }\r
+\r
+ public String getBridgeDomain() {\r
+ return bridgeDomain;\r
+ }\r
+\r
+ public VhostUserCommandBuilder setBridgeDomain(String bridgeDomain) {\r
+ this.bridgeDomain = bridgeDomain;\r
+ return this;\r
+ }\r
+\r
+ /**\r
+ * VhostUserCommand build method.\r
+ *\r
+ * @return VhostUserCommand\r
+ * @throws IllegalArgumentException if name, operation or socket is null.\r
+ */\r
+ public VhostUserCommand build() {\r
+ Preconditions.checkArgument(this.name != null);\r
+ Preconditions.checkArgument(this.operation != null);\r
+ if (operation == Operations.PUT) {\r
+ Preconditions.checkArgument(this.socket != null);\r
+ }\r
+\r
+ return new VhostUserCommand(this);\r
+ }\r
+ }\r
+}\r
--- /dev/null
+/*
+ * Copyright (c) 2016 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.groupbasedpolicy.renderer.vpp.event;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+
+public abstract class DtoChangeEvent<T extends DataObject> {
+
+ protected final InstanceIdentifier<T> iid;
+ protected final Optional<T> before;
+ protected final Optional<T> after;
+
+ public static enum DtoModificationType {
+ CREATED, UPDATED, DELETED;
+ }
+
+ public DtoChangeEvent(@Nonnull InstanceIdentifier<T> iid, @Nullable T before, @Nullable T after) {
+ this.iid = Preconditions.checkNotNull(iid);
+ Preconditions.checkArgument(!(before == null && after == null),
+ "before and after cannot be null at the same time");
+ this.before = Optional.fromNullable(before);
+ this.after = Optional.fromNullable(after);
+ }
+
+ public @Nonnull InstanceIdentifier<T> getIid() {
+ return iid;
+ }
+
+ public Optional<T> getBefore() {
+ return before;
+ }
+
+ public Optional<T> getAfter() {
+ return after;
+ }
+
+ /**
+ * Returns:<br>
+ * {@link DtoModificationType#CREATED} - when {@link #isDtoCreated()} is {@code true}<br>
+ * {@link DtoModificationType#UPDATED} - when {@link #isDtoUpdated()} is {@code true}<br>
+ * {@link DtoModificationType#DELETED} - when {@link #isDtoDeleted()} is {@code true}
+ *
+ * @return DtoModificationType
+ */
+ public @Nonnull DtoModificationType getDtoModificationType() {
+ if (isDtoCreated()) {
+ return DtoModificationType.CREATED;
+ }
+ if (isDtoUpdated()) {
+ return DtoModificationType.UPDATED;
+ }
+ if (isDtoDeleted()) {
+ return DtoModificationType.DELETED;
+ }
+ throw new IllegalStateException("Unknown DTO modification type.");
+ }
+
+ /**
+ * Checks if {@link #getBefore()} is NOT present and if {@link #getAfter()} is present
+ *
+ * @return {@code true} if DTO is created; {@code false} otherwise
+ */
+ public boolean isDtoCreated() {
+ return !before.isPresent() && after.isPresent();
+ }
+
+ /**
+ * Checks if {@link #getBefore()} is present and if {@link #getAfter()} is present
+ *
+ * @return {@code true} if DTO is updated; {@code false} otherwise
+ */
+ public boolean isDtoUpdated() {
+ return before.isPresent() && after.isPresent();
+ }
+
+ /**
+ * Checks if {@link #getBefore()} is present and if {@link #getAfter()} is NOT present
+ *
+ * @return {@code true} if DTO is deleted; {@code false} otherwise
+ */
+ public boolean isDtoDeleted() {
+ return before.isPresent() && !after.isPresent();
+ }
+
+ @Override
+ public int hashCode() {
+ final int prime = 31;
+ int result = 1;
+ result = prime * result + ((after == null) ? 0 : after.hashCode());
+ result = prime * result + ((before == null) ? 0 : before.hashCode());
+ result = prime * result + ((iid == null) ? 0 : iid.hashCode());
+ return result;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null)
+ return false;
+ if (!(obj instanceof DtoChangeEvent))
+ return false;
+ DtoChangeEvent other = (DtoChangeEvent) obj;
+ if (after == null) {
+ if (other.after != null)
+ return false;
+ } else if (!after.equals(other.after))
+ return false;
+ if (before == null) {
+ if (other.before != null)
+ return false;
+ } else if (!before.equals(other.before))
+ return false;
+ if (iid == null) {
+ if (other.iid != null)
+ return false;
+ } else if (!iid.equals(other.iid))
+ return false;
+ return true;
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 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.groupbasedpolicy.renderer.vpp.event;
+
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNode;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus.ConnectionStatus;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+
+public class NodeOperEvent extends DtoChangeEvent<Node> {
+
+ public NodeOperEvent(InstanceIdentifier<Node> iid, Node before, Node after) {
+ super(iid, before, after);
+ if (before != null) {
+ Preconditions.checkArgument(before.getAugmentation(NetconfNode.class) != null);
+ }
+ if (after != null) {
+ Preconditions.checkArgument(after.getAugmentation(NetconfNode.class) != null);
+ }
+ }
+
+ public boolean isAfterConnected() {
+ return isConnected(after);
+ }
+
+ public boolean isBeforeConnected() {
+ return isConnected(before);
+ }
+
+ private static boolean isConnected(Optional<Node> potentialNode) {
+ if (!potentialNode.isPresent()) {
+ return false;
+ }
+ NetconfNode netconfNode = potentialNode.get().getAugmentation(NetconfNode.class);
+ if (ConnectionStatus.Connected == netconfNode.getConnectionStatus()) {
+ return true;
+ }
+ return false;
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 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.groupbasedpolicy.renderer.vpp.event;
+
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class VppEndpointConfEvent extends DtoChangeEvent<VppEndpoint> {
+
+ public VppEndpointConfEvent(InstanceIdentifier<VppEndpoint> iid, VppEndpoint before, VppEndpoint after) {
+ super(iid, before, after);
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 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.groupbasedpolicy.renderer.vpp.iface;
+
+import javax.annotation.Nonnull;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.ConfigCommand;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.VhostUserCommand;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.commands.VhostUserCommand.VhostUserCommandBuilder;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.event.NodeOperEvent;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.event.VppEndpointConfEvent;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.util.General.Operations;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.util.MountedDataBrokerProvider;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.vpp.endpoint.InterfaceTypeChoice;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.vpp.endpoint._interface.type.choice.VhostUserCase;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VhostUserRole;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Strings;
+import com.google.common.eventbus.Subscribe;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+
+public class InterfaceManager implements AutoCloseable {
+
+ private static final Logger LOG = LoggerFactory.getLogger(InterfaceManager.class);
+ private final MountedDataBrokerProvider mountDataProvider;
+ private final VppEndpointLocationProvider vppEndpointLocationProvider;
+
+ public InterfaceManager(@Nonnull MountedDataBrokerProvider mountDataProvider, @Nonnull DataBroker dataProvider) {
+ this.mountDataProvider = Preconditions.checkNotNull(mountDataProvider);
+ this.vppEndpointLocationProvider = new VppEndpointLocationProvider(dataProvider);
+ }
+
+ @Subscribe
+ public void vppEndpointChanged(VppEndpointConfEvent event) {
+ switch (event.getDtoModificationType()) {
+ case CREATED:
+ vppEndpointCreated(event.getAfter().get());
+ break;
+ case UPDATED:
+ vppEndpointDeleted(event.getBefore().get());
+ vppEndpointCreated(event.getAfter().get());
+ break;
+ case DELETED:
+ vppEndpointDeleted(event.getBefore().get());
+ break;
+ }
+ }
+
+ private void vppEndpointCreated(VppEndpoint vppEndpoint) {
+ Optional<ConfigCommand> potentialIfaceCommand = createInterfaceWithoutBdCommand(vppEndpoint, Operations.PUT);
+ if (!potentialIfaceCommand.isPresent()) {
+ return;
+ }
+ ConfigCommand ifaceWithoutBdCommand = potentialIfaceCommand.get();
+ InstanceIdentifier<?> vppNodeIid = vppEndpoint.getVppNodePath();
+ Optional<DataBroker> potentialVppDataProvider = mountDataProvider.getDataBrokerForMountPoint(vppNodeIid);
+ if (!potentialVppDataProvider.isPresent()) {
+ LOG.debug("Cannot get data broker for mount point {}", vppNodeIid);
+ return;
+ }
+ DataBroker vppDataBroker = potentialVppDataProvider.get();
+ createIfaceOnVpp(ifaceWithoutBdCommand, vppDataBroker, vppEndpoint, vppNodeIid);
+ }
+
+ private void createIfaceOnVpp(ConfigCommand createIfaceWithoutBdCommand, DataBroker vppDataBroker,
+ VppEndpoint vppEndpoint, InstanceIdentifier<?> vppNodeIid) {
+ ReadWriteTransaction rwTx = vppDataBroker.newReadWriteTransaction();
+ createIfaceWithoutBdCommand.execute(rwTx);
+ Futures.addCallback(rwTx.submit(), new FutureCallback<Void>() {
+
+ @Override
+ public void onSuccess(Void result) {
+ LOG.debug("Create interface on VPP command was successful:\nVPP: {}\nCommand: {}", vppNodeIid,
+ createIfaceWithoutBdCommand);
+ vppEndpointLocationProvider.createLocationForVppEndpoint(vppEndpoint);
+ }
+
+ @Override
+ public void onFailure(Throwable t) {
+ LOG.error("Create interface on VPP command was NOT successful:\nVPP: {}\nCommand: {}", vppNodeIid,
+ createIfaceWithoutBdCommand, t);
+ }
+ });
+ }
+
+ private void vppEndpointDeleted(VppEndpoint vppEndpoint) {
+ Optional<ConfigCommand> potentialIfaceCommand = createInterfaceWithoutBdCommand(vppEndpoint, Operations.DELETE);
+ if (!potentialIfaceCommand.isPresent()) {
+ return;
+ }
+ ConfigCommand ifaceWithoutBdCommand = potentialIfaceCommand.get();
+ InstanceIdentifier<?> vppNodeIid = vppEndpoint.getVppNodePath();
+ Optional<DataBroker> potentialVppDataProvider = mountDataProvider.getDataBrokerForMountPoint(vppNodeIid);
+ if (!potentialVppDataProvider.isPresent()) {
+ LOG.debug("Cannot get data broker for mount point {}", vppNodeIid);
+ return;
+ }
+ DataBroker vppDataBroker = potentialVppDataProvider.get();
+ deleteIfaceOnVpp(ifaceWithoutBdCommand, vppDataBroker, vppEndpoint, vppNodeIid);
+ }
+
+ private void deleteIfaceOnVpp(ConfigCommand deleteIfaceWithoutBdCommand, DataBroker vppDataBroker,
+ VppEndpoint vppEndpoint, InstanceIdentifier<?> vppNodeIid) {
+ ReadWriteTransaction rwTx = vppDataBroker.newReadWriteTransaction();
+ deleteIfaceWithoutBdCommand.execute(rwTx);
+ Futures.addCallback(rwTx.submit(), new FutureCallback<Void>() {
+
+ @Override
+ public void onSuccess(Void result) {
+ LOG.debug("Delete interface on VPP command was successful:\nVPP: {}\nCommand: {}", vppNodeIid,
+ deleteIfaceWithoutBdCommand);
+ vppEndpointLocationProvider.deleteLocationForVppEndpoint(vppEndpoint);
+ }
+
+ @Override
+ public void onFailure(Throwable t) {
+ LOG.error("Delete interface on VPP command was NOT successful:\nVPP: {}\nCommand: {}", vppNodeIid,
+ deleteIfaceWithoutBdCommand, t);
+ }
+ });
+ }
+
+ @Subscribe
+ public void vppNodeChanged(NodeOperEvent event) {
+ switch (event.getDtoModificationType()) {
+ case CREATED:
+ if (event.isAfterConnected()) {
+ // TODO read VppEndpoints or cache them during vppEndpointChanged()
+ }
+ break;
+ case UPDATED:
+ if (!event.isBeforeConnected() && event.isAfterConnected()) {
+ // TODO reconciliation - diff between disconnected snapshot and current snapshot
+ }
+ break;
+ case DELETED:
+ if (event.isBeforeConnected()) {
+ // TODO we could do snapshot of VppEndpoints
+ // which can be used for reconciliation
+ }
+ break;
+ }
+ }
+
+ private static Optional<ConfigCommand> createInterfaceWithoutBdCommand(@Nonnull VppEndpoint vppEp,
+ @Nonnull Operations operations) {
+ if (!hasNodeAndInterface(vppEp)) {
+ LOG.debug("Interface command is not created for {}", vppEp);
+ return Optional.absent();
+ }
+ VhostUserCommandBuilder builder = VhostUserCommand.builder();
+ builder.setName(vppEp.getVppInterfaceName());
+ InterfaceTypeChoice interfaceTypeChoice = vppEp.getInterfaceTypeChoice();
+ if (interfaceTypeChoice instanceof VhostUserCase) {
+ VhostUserCase vhostUserIface = (VhostUserCase) interfaceTypeChoice;
+ String socket = vhostUserIface.getSocket();
+ if (Strings.isNullOrEmpty(socket)) {
+ LOG.debug("Vhost user interface command is not created because socket is missing. {}", vppEp);
+ return Optional.absent();
+ }
+ builder.setSocket(socket);
+ builder.setRole(VhostUserRole.Client);
+ }
+ VhostUserCommand vhostUserCommand =
+ builder.setOperation(operations).setDescription(vppEp.getDescription()).build();
+ return Optional.of(vhostUserCommand);
+ }
+
+ private static boolean hasNodeAndInterface(VppEndpoint vppEp) {
+ if (vppEp.getVppNodePath() == null) {
+ LOG.trace("vpp-node is missing. {}", vppEp);
+ return false;
+ }
+ if (Strings.isNullOrEmpty(vppEp.getVppInterfaceName())) {
+ LOG.trace("vpp-interface-name is missing. {}", vppEp);
+ return false;
+ }
+ return true;
+ }
+
+ @Override
+ public void close() throws Exception {
+ vppEndpointLocationProvider.close();
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 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.groupbasedpolicy.renderer.vpp.iface;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.util.IidFactory;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.AbsoluteLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.AbsoluteLocationBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.base_endpoint.rev160427.has.absolute.location.absolute.location.location.type.ExternalLocationCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.ProviderName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.LocationProvider;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.LocationProviderBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.location.provider.ProviderAddressEndpointLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.location.provider.ProviderAddressEndpointLocationBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.location.provider.ProviderAddressEndpointLocationKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.Preconditions;
+import com.google.common.util.concurrent.FutureCallback;
+import com.google.common.util.concurrent.Futures;
+
+public class VppEndpointLocationProvider implements AutoCloseable {
+
+ private static final Logger LOG = LoggerFactory.getLogger(VppEndpointLocationProvider.class);
+ public static final ProviderName VPP_ENDPOINT_LOCATION_PROVIDER =
+ new ProviderName("VPP endpoint location provider");
+ public static final long PROVIDER_PRIORITY = 10L;
+ private static final String INTERFACE_PATH = "/ietf-interfaces:interfaces/ietf-interfaces:interface";
+ private final DataBroker dataProvider;
+
+ public VppEndpointLocationProvider(DataBroker dataProvider) {
+ this.dataProvider = Preconditions.checkNotNull(dataProvider);
+ LocationProvider locationProvider = new LocationProviderBuilder().setProvider(VPP_ENDPOINT_LOCATION_PROVIDER)
+ .setPriority(PROVIDER_PRIORITY)
+ .build();
+ WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
+ wTx.put(LogicalDatastoreType.CONFIGURATION, IidFactory.locationProviderIid(VPP_ENDPOINT_LOCATION_PROVIDER),
+ locationProvider, true);
+
+ Futures.addCallback(wTx.submit(), new FutureCallback<Void>() {
+
+ @Override
+ public void onSuccess(Void result) {
+ LOG.trace("{} was created", VPP_ENDPOINT_LOCATION_PROVIDER.getValue());
+ }
+
+ @Override
+ public void onFailure(Throwable t) {
+ LOG.error("{} was NOT created", VPP_ENDPOINT_LOCATION_PROVIDER.getValue());
+ }
+ });
+ }
+
+ public void createLocationForVppEndpoint(VppEndpoint vppEndpoint) {
+ ProviderAddressEndpointLocation providerAddressEndpointLocation =
+ createProviderAddressEndpointLocation(vppEndpoint);
+ WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
+ wTx.put(LogicalDatastoreType.CONFIGURATION,
+ IidFactory.providerAddressEndpointLocationIid(VPP_ENDPOINT_LOCATION_PROVIDER,
+ providerAddressEndpointLocation.getKey()),
+ providerAddressEndpointLocation);
+
+ Futures.addCallback(wTx.submit(), new FutureCallback<Void>() {
+
+ @Override
+ public void onSuccess(Void result) {
+ LOG.trace("{} provides location: {}", VPP_ENDPOINT_LOCATION_PROVIDER.getValue(),
+ providerAddressEndpointLocation);
+ }
+
+ @Override
+ public void onFailure(Throwable t) {
+ LOG.error("{} failed to provide location: {}", VPP_ENDPOINT_LOCATION_PROVIDER.getValue(),
+ providerAddressEndpointLocation, t);
+ }
+ });
+ }
+
+ public static ProviderAddressEndpointLocation createProviderAddressEndpointLocation(VppEndpoint vppEndpoint) {
+ String restIfacePath = INTERFACE_PATH + createRestInterfaceKey(vppEndpoint.getVppInterfaceName());
+ AbsoluteLocation absoluteLocation = new AbsoluteLocationBuilder()
+ .setLocationType(new ExternalLocationCaseBuilder().setExternalNodeMountPoint(vppEndpoint.getVppNodePath())
+ .setExternalNodeConnector(restIfacePath)
+ .build())
+ .build();
+ return new ProviderAddressEndpointLocationBuilder()
+ .setKey(createProviderAddressEndpointLocationKey(vppEndpoint))
+ .setAbsoluteLocation(absoluteLocation)
+ .build();
+ }
+
+ public void deleteLocationForVppEndpoint(VppEndpoint vppEndpoint) {
+ ProviderAddressEndpointLocationKey provAddrEpLocKey = createProviderAddressEndpointLocationKey(vppEndpoint);
+ WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
+ wTx.delete(LogicalDatastoreType.CONFIGURATION,
+ IidFactory.providerAddressEndpointLocationIid(VPP_ENDPOINT_LOCATION_PROVIDER, provAddrEpLocKey));
+ Futures.addCallback(wTx.submit(), new FutureCallback<Void>() {
+
+ @Override
+ public void onSuccess(Void result) {
+ LOG.trace("{} removes location: {}", VPP_ENDPOINT_LOCATION_PROVIDER.getValue(), provAddrEpLocKey);
+ }
+
+ @Override
+ public void onFailure(Throwable t) {
+ LOG.error("{} failed to remove location: {}", VPP_ENDPOINT_LOCATION_PROVIDER.getValue(),
+ provAddrEpLocKey, t);
+ }
+ });
+ }
+
+ private static ProviderAddressEndpointLocationKey createProviderAddressEndpointLocationKey(VppEndpoint vppEndpoint) {
+ return new ProviderAddressEndpointLocationKey(vppEndpoint.getAddress(), vppEndpoint.getAddressType(),
+ vppEndpoint.getContextId(), vppEndpoint.getContextType());
+ }
+
+ private static String createRestInterfaceKey(String ifaceName) {
+ return "[ietf-interfaces:name='" + ifaceName + "']";
+ }
+
+ @Override
+ public void close() throws Exception {
+ WriteTransaction wTx = dataProvider.newWriteOnlyTransaction();
+ wTx.delete(LogicalDatastoreType.CONFIGURATION, IidFactory.locationProviderIid(VPP_ENDPOINT_LOCATION_PROVIDER));
+ wTx.submit();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 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.groupbasedpolicy.renderer.vpp.listener;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.util.DataTreeChangeHandler;
+import org.opendaylight.groupbasedpolicy.util.IidFactory;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.RendererName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererPolicy;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class RendererPolicyListener extends DataTreeChangeHandler<RendererPolicy> {
+
+ // TODO move to common place
+ private static final RendererName RENDERER_NAME = new RendererName("VPP renderer");
+
+ protected RendererPolicyListener(DataBroker dataProvider) {
+ super(dataProvider);
+ registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
+ IidFactory.rendererIid(RENDERER_NAME).child(RendererPolicy.class)));
+ }
+
+ @Override
+ protected void onWrite(DataObjectModification<RendererPolicy> rootNode,
+ InstanceIdentifier<RendererPolicy> rootIdentifier) {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ protected void onDelete(DataObjectModification<RendererPolicy> rootNode,
+ InstanceIdentifier<RendererPolicy> rootIdentifier) {
+ // TODO Auto-generated method stub
+
+ }
+
+ @Override
+ protected void onSubtreeModified(DataObjectModification<RendererPolicy> rootNode,
+ InstanceIdentifier<RendererPolicy> rootIdentifier) {
+ // TODO Auto-generated method stub
+
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 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.groupbasedpolicy.renderer.vpp.listener;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.event.VppEndpointConfEvent;
+import org.opendaylight.groupbasedpolicy.util.DataTreeChangeHandler;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.Config;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.Preconditions;
+import com.google.common.eventbus.EventBus;
+
+public class VppEndpointListener extends DataTreeChangeHandler<VppEndpoint> {
+
+ private static final Logger LOG = LoggerFactory.getLogger(VppEndpointListener.class);
+ private EventBus eventBus;
+
+ public VppEndpointListener(DataBroker dataProvider, EventBus eventBus) {
+ super(dataProvider);
+ this.eventBus = Preconditions.checkNotNull(eventBus);
+ registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
+ InstanceIdentifier.builder(Config.class).child(VppEndpoint.class).build()));
+ }
+
+ @Override
+ protected void onWrite(DataObjectModification<VppEndpoint> rootNode,
+ InstanceIdentifier<VppEndpoint> rootIdentifier) {
+ VppEndpointConfEvent event =
+ new VppEndpointConfEvent(rootIdentifier, rootNode.getDataBefore(), rootNode.getDataAfter());
+ LOG.trace("Dispatching event on write: {}", event);
+ eventBus.post(event);
+ }
+
+ @Override
+ protected void onDelete(DataObjectModification<VppEndpoint> rootNode,
+ InstanceIdentifier<VppEndpoint> rootIdentifier) {
+ VppEndpointConfEvent event =
+ new VppEndpointConfEvent(rootIdentifier, rootNode.getDataBefore(), rootNode.getDataAfter());
+ LOG.trace("Dispatching event on delete: {}", event);
+ eventBus.post(event);
+ }
+
+ @Override
+ protected void onSubtreeModified(DataObjectModification<VppEndpoint> rootNode,
+ InstanceIdentifier<VppEndpoint> rootIdentifier) {
+ VppEndpointConfEvent event =
+ new VppEndpointConfEvent(rootIdentifier, rootNode.getDataBefore(), rootNode.getDataAfter());
+ LOG.trace("Dispatching event on subtree modified: {}", event);
+ eventBus.post(event);
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 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.groupbasedpolicy.renderer.vpp.listener;
+
+import java.util.Collection;
+
+import javax.annotation.Nonnull;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.event.NodeOperEvent;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.manager.VppNodeManager;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yangtools.concepts.ListenerRegistration;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.Preconditions;
+import com.google.common.eventbus.EventBus;
+
+public class VppNodeListener implements DataTreeChangeListener<Node>, AutoCloseable {
+
+ private static final Logger LOG = LoggerFactory.getLogger(VppNodeListener.class);
+
+ private final ListenerRegistration<VppNodeListener> listenerRegistration;
+ private final VppNodeManager nodeManager;
+ private final EventBus eventBus;
+
+ public VppNodeListener(DataBroker dataBroker, VppNodeManager nodeManager, EventBus eventBus) {
+ this.nodeManager = Preconditions.checkNotNull(nodeManager);
+ this.eventBus = Preconditions.checkNotNull(eventBus);
+ // Register listener
+ final DataTreeIdentifier<Node> networkTopologyPath = new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL,
+ InstanceIdentifier.builder(NetworkTopology.class).child(Topology.class).child(Node.class).build());
+ listenerRegistration =
+ Preconditions.checkNotNull(dataBroker.registerDataTreeChangeListener(networkTopologyPath, this));
+ LOG.info("Network-Topology VppNodelistener registered");
+ }
+
+ @Override
+ public void onDataTreeChanged(@Nonnull Collection<DataTreeModification<Node>> changes) {
+ LOG.debug("Topology Node changed. Changes {}", changes);
+
+ for (DataTreeModification<Node> modification : changes) {
+ DataObjectModification<Node> rootNode = modification.getRootNode();
+ Node dataAfter = rootNode.getDataAfter();
+ Node dataBefore = rootNode.getDataBefore();
+ NodeOperEvent event =
+ new NodeOperEvent(modification.getRootPath().getRootIdentifier(), dataBefore, dataAfter);
+ eventBus.post(event);
+ nodeManager.syncNodes(dataAfter, dataBefore);
+ }
+ }
+
+ public ListenerRegistration<VppNodeListener> getRegistrationObject() {
+ return listenerRegistration;
+ }
+
+ @Override
+ public void close() throws Exception {
+ listenerRegistration.close();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 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.groupbasedpolicy.renderer.vpp.manager;
+
+import static org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus.ConnectionStatus.Connected;
+import static org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus.ConnectionStatus.Connecting;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.MountPoint;
+import org.opendaylight.controller.md.sal.binding.api.MountPointService;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppNodeWriter;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.RendererName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.nodes.RendererNode;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.nodes.RendererNodeBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.nodes.RendererNodeKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNode;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+
+public class VppNodeManager {
+
+ public static final RendererName vppRenderer = new RendererName("vpp-renderer");
+ private static final TopologyId TOPOLOGY_ID = new TopologyId("topology-netconf");
+ private static final Logger LOG = LoggerFactory.getLogger(VppNodeManager.class);
+ private static final Map<InstanceIdentifier<Node>, DataBroker> netconfNodeCache = new HashMap<>();
+ private static final String V3PO_CAPABILITY = "(urn:opendaylight:params:xml:ns:yang:v3po?revision=2015-01-05)v3po";
+ private static final String INTERFACES_CAPABILITY =
+ "(urn:ietf:params:xml:ns:yang:ietf-interfaces?revision=2014-05-08)ietf-interfaces";
+ private final DataBroker dataBroker;
+ private final MountPointService mountService;
+ private final List<String> requiredCapabilities;
+
+ public VppNodeManager(DataBroker dataBroker, BindingAwareBroker.ProviderContext session) {
+ this.dataBroker = Preconditions.checkNotNull(dataBroker);
+ mountService = Preconditions.checkNotNull(session.getSALService(MountPointService.class));
+ requiredCapabilities = initializeRequiredCapabilities();
+ }
+
+ static DataBroker getDataBrokerFromCache(InstanceIdentifier<Node> iid) {
+ return netconfNodeCache.get(iid); // TODO read from DS
+ }
+
+ /**
+ * Synchronizes nodes to DataStore based on their modification state which results in
+ * create/update/remove of Node.
+ */
+ public void syncNodes(Node dataAfter, Node dataBefore) {
+ // New node
+ if (dataBefore == null && dataAfter != null) {
+ createNode(dataAfter);
+ }
+ // Connected/disconnected node
+ if (dataBefore != null && dataAfter != null) {
+ updateNode(dataAfter);
+ }
+ // Removed node
+ if (dataBefore != null && dataAfter == null) {
+ removeNode(dataBefore);
+ }
+ }
+
+ private void createNode(Node node) {
+ LOG.info("Registering new node {}", node.getNodeId().getValue());
+ NetconfNode netconfNode = getNodeAugmentation(node);
+ if (netconfNode == null) {
+ return;
+ }
+ NetconfNodeConnectionStatus.ConnectionStatus connectionStatus = netconfNode.getConnectionStatus();
+ switch (connectionStatus) {
+ case Connecting:
+ LOG.info("Connecting device {} ...", node.getNodeId().getValue());
+ break;
+ case Connected:
+ resolveConnectedNode(node, netconfNode);
+ LOG.info("Node {} is capable and ready", node.getNodeId().getValue());
+ break;
+ default:
+ break;
+ }
+ }
+
+ private void updateNode(Node node) {
+ NetconfNode netconfNode = getNodeAugmentation(node);
+ if (netconfNode == null || netconfNode.getConnectionStatus() == null) {
+ return;
+ }
+ NetconfNodeConnectionStatus.ConnectionStatus afterNodeStatus = netconfNode.getConnectionStatus();
+ if (afterNodeStatus.equals(Connected)) {
+ resolveConnectedNode(node, netconfNode);
+ LOG.info("Node {} is capable and ready", node.getNodeId().getValue());
+ }
+ if (afterNodeStatus.equals(Connecting)) {
+ resolveDisconnectedNode(node);
+ LOG.info("Node {} has been disconnected, removing from available nodes", node.getNodeId().getValue());
+ }
+ }
+
+ private void removeNode(Node node) {
+ resolveDisconnectedNode(node);
+ LOG.info("Node {} has been removed", node.getNodeId().getValue());
+ }
+
+ private void resolveConnectedNode(Node node, NetconfNode netconfNode) {
+ InstanceIdentifier<Node> mountPointIid = getMountpointIid(node);
+ // Mountpoint iid == path in renderer-node
+ RendererNode rendererNode = remapNode(mountPointIid);
+ VppNodeWriter vppNodeWriter = new VppNodeWriter();
+ vppNodeWriter.cache(rendererNode);
+ if (!isCapableNetconfDevice(node, netconfNode)) {
+ return;
+ }
+ vppNodeWriter.commitToDatastore(dataBroker);
+ DataBroker mountpoint = getNodeMountPoint(mountPointIid);
+ netconfNodeCache.put(mountPointIid, mountpoint);
+ }
+
+ private void resolveDisconnectedNode(Node node) {
+ InstanceIdentifier<Node> mountPointIid = getMountpointIid(node);
+ RendererNode rendererNode = remapNode(mountPointIid);
+ VppNodeWriter vppNodeWriter = new VppNodeWriter();
+ vppNodeWriter.cache(rendererNode);
+ vppNodeWriter.removeFromDatastore(dataBroker);
+ netconfNodeCache.remove(mountPointIid);
+ }
+
+ private RendererNode remapNode(InstanceIdentifier<Node> path) {
+ RendererNodeBuilder rendererNodeBuilder = new RendererNodeBuilder();
+ rendererNodeBuilder.setKey(new RendererNodeKey(path)).setNodePath(path);
+ return rendererNodeBuilder.build();
+ }
+
+ private InstanceIdentifier<Node> getMountpointIid(Node node) {
+ return InstanceIdentifier.builder(NetworkTopology.class)
+ .child(Topology.class, new TopologyKey(TOPOLOGY_ID))
+ .child(Node.class, new NodeKey(node.getNodeId()))
+ .build();
+ }
+
+ private boolean isCapableNetconfDevice(Node node, NetconfNode netconfAugmentation) {
+ if (netconfAugmentation.getAvailableCapabilities() == null
+ || netconfAugmentation.getAvailableCapabilities().getAvailableCapability() == null
+ || netconfAugmentation.getAvailableCapabilities().getAvailableCapability().isEmpty()) {
+ LOG.warn("Node {} does not contain any capabilities", node.getNodeId().getValue());
+ return false;
+ }
+ if (!capabilityCheck(netconfAugmentation.getAvailableCapabilities().getAvailableCapability())) {
+ LOG.warn("Node {} does not contain all capabilities required by vpp-renderer", node.getNodeId().getValue());
+ return false;
+ }
+ return true;
+ }
+
+ private boolean capabilityCheck(final List<String> capabilities) {
+ for (String requiredCapability : requiredCapabilities) {
+ if (!capabilities.contains(requiredCapability)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ private DataBroker getNodeMountPoint(InstanceIdentifier<Node> mountPointIid) {
+ Optional<MountPoint> optionalObject = mountService.getMountPoint(mountPointIid);
+ MountPoint mountPoint;
+ if (optionalObject.isPresent()) {
+ mountPoint = optionalObject.get();
+ if (mountPoint != null) {
+ Optional<DataBroker> optionalDataBroker = mountPoint.getService(DataBroker.class);
+ if (optionalDataBroker.isPresent()) {
+ return optionalDataBroker.get();
+ } else {
+ LOG.debug("Cannot obtain data broker from mountpoint {}", mountPoint);
+ }
+ } else {
+ LOG.debug("Cannot obtain mountpoint with IID {}", mountPointIid);
+ }
+ }
+ return null;
+ }
+
+ private NetconfNode getNodeAugmentation(Node node) {
+ NetconfNode netconfNode = node.getAugmentation(NetconfNode.class);
+ if (netconfNode == null) {
+ LOG.warn("Node {} is not a netconf device", node.getNodeId().getValue());
+ return null;
+ }
+ return netconfNode;
+ }
+
+ /**
+ * Initialize all common capabilities required by VPP renderer. Any connected node is examined
+ * whether it's
+ * an appropriate device to handle configuration created by this renderer. A device must support
+ * all capabilities
+ * in list below.
+ *
+ * @return list of string representations of required capabilities
+ */
+ private List<String> initializeRequiredCapabilities() {
+ // Required device capabilities
+
+ String[] capabilityEntries = {V3PO_CAPABILITY, INTERFACES_CAPABILITY};
+ return Arrays.asList(capabilityEntries);
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 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.groupbasedpolicy.renderer.vpp.sf;
+
+import java.util.List;
+
+import org.opendaylight.groupbasedpolicy.api.Validator;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ActionDefinitionId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ActionDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.subject.feature.instances.ActionInstance;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.action.definition.SupportedParameterValues;
+
+/**
+ * Represent an action definition, and provide tools for generating
+ * flow instructions based on the action.
+ */
+public abstract class Action implements Validator<ActionInstance> {
+
+ /**
+ * Get the action definition for this action.
+ *
+ * @return the {@link ActionDefinition} for this action
+ */
+ public abstract ActionDefinitionId getId();
+
+ /**
+ * Get the action definition for this action.
+ *
+ * @return the {@link ActionDefinition} for this action
+ */
+ public abstract ActionDefinition getActionDef();
+
+ /**
+ * The result represents supported parameters for the action by renderer.
+ *
+ * @return list of supported parameters by the action
+ */
+ public abstract List<SupportedParameterValues> getSupportedParameterValues();
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 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.groupbasedpolicy.renderer.vpp.sf;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.opendaylight.groupbasedpolicy.api.ValidationResult;
+import org.opendaylight.groupbasedpolicy.api.sf.AllowActionDefinition;
+import org.opendaylight.groupbasedpolicy.dto.ValidationResultBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ActionDefinitionId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ActionDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.subject.feature.instances.ActionInstance;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.action.definition.SupportedParameterValues;
+
+/**
+ * Allow action.
+ */
+public class AllowAction extends Action {
+
+ @Override
+ public ActionDefinitionId getId() {
+ return AllowActionDefinition.ID;
+ }
+
+ @Override
+ public ActionDefinition getActionDef() {
+ return AllowActionDefinition.DEFINITION;
+ }
+
+ @Override
+ public ValidationResult validate(ActionInstance actionInstance) {
+ return new ValidationResultBuilder().success().build();
+ }
+
+ @Override
+ public List<SupportedParameterValues> getSupportedParameterValues() {
+ // allow action definition has no parameter
+ return Collections.emptyList();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 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.groupbasedpolicy.renderer.vpp.sf;
+
+import java.util.List;
+import java.util.Map;
+
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierDefinitionId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ClassifierDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValue;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.classifier.definition.SupportedParameterValues;
+
+/**
+ * Represent a classifier definition.
+ */
+public abstract class Classifier {
+
+ protected final Classifier parent;
+
+ public static final EtherTypeClassifier ETHER_TYPE_CL = new EtherTypeClassifier(null);
+ public static final IpProtoClassifier IP_PROTO_CL = new IpProtoClassifier(ETHER_TYPE_CL);
+
+ protected Classifier(Classifier parent) {
+ this.parent = parent;
+ }
+
+ /**
+ * Get the classifier definition id for this classifier.
+ *
+ * @return the {@link ClassifierDefinitionId} for this classifier
+ */
+ public abstract ClassifierDefinitionId getId();
+
+ /**
+ * Get the classifier definition for this classifier.
+ *
+ * @return the {@link ClassifierDefinition} for this classifier
+ */
+ public abstract ClassifierDefinition getClassifierDefinition();
+
+ /**
+ * Get parent for this classifier.
+ *
+ * @return parent classifier, see {@link Classifier}
+ */
+ public final Classifier getParent() {
+ return parent;
+ }
+
+ /**
+ * The result represents supported parameters for the classifier by renderer.
+ *
+ * @return list of supported parameters by the classifier
+ */
+ public abstract List<SupportedParameterValues> getSupportedParameterValues();
+
+ /**
+ * Checks presence of required {@code params} in order to decide if classifier can update
+ * {@code matches} properly.
+ *
+ * @param params inserted parameters, not null
+ * @throws IllegalArgumentException when any of required {@code params} is not present
+ */
+ protected abstract void checkPresenceOfRequiredParams(Map<String, ParameterValue> params);
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 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.groupbasedpolicy.renderer.vpp.sf;
+
+import java.util.List;
+import java.util.Map;
+
+import org.opendaylight.groupbasedpolicy.api.sf.EtherTypeClassifierDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierDefinitionId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ParameterName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ClassifierDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValue;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.parameters.type.parameter.type.IntBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.classifier.definition.SupportedParameterValues;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.classifier.definition.SupportedParameterValuesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.supported._int.value.fields.SupportedIntValue;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.supported._int.value.fields.SupportedIntValueBuilder;
+
+import com.google.common.collect.ImmutableList;
+
+/**
+ * Match on the ether type of the traffic.
+ */
+public class EtherTypeClassifier extends Classifier {
+
+ public EtherTypeClassifier(Classifier parent) {
+ super(parent);
+ }
+
+ @Override
+ public ClassifierDefinitionId getId() {
+ return EtherTypeClassifierDefinition.ID;
+ }
+
+ @Override
+ public ClassifierDefinition getClassifierDefinition() {
+ return EtherTypeClassifierDefinition.DEFINITION;
+ }
+
+ @Override
+ public List<SupportedParameterValues> getSupportedParameterValues() {
+
+ List<SupportedIntValue> values = ImmutableList.of(
+ new SupportedIntValueBuilder().setValue(EtherTypeClassifierDefinition.IPv4_VALUE).build(),
+ new SupportedIntValueBuilder().setValue(EtherTypeClassifierDefinition.IPv6_VALUE).build());
+ SupportedParameterValuesBuilder builder = new SupportedParameterValuesBuilder();
+ builder.setParameterName(new ParameterName(EtherTypeClassifierDefinition.ETHERTYPE_PARAM));
+ builder.setParameterType(new IntBuilder().setSupportedIntValue(values).build());
+
+ return ImmutableList.of(builder.build());
+ }
+
+ @Override
+ protected void checkPresenceOfRequiredParams(Map<String, ParameterValue> params) {
+ if (params.get(EtherTypeClassifierDefinition.ETHERTYPE_PARAM) == null) {
+ throw new IllegalArgumentException(
+ "Parameter " + EtherTypeClassifierDefinition.ETHERTYPE_PARAM + " not specified.");
+ }
+ if (params.get(EtherTypeClassifierDefinition.ETHERTYPE_PARAM).getIntValue() == null) {
+ throw new IllegalArgumentException(
+ "Value of " + EtherTypeClassifierDefinition.ETHERTYPE_PARAM + " parameter is not present.");
+ }
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2014 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.groupbasedpolicy.renderer.vpp.sf;
+
+import java.util.List;
+import java.util.Map;
+
+import org.opendaylight.groupbasedpolicy.api.sf.IpProtoClassifierDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ClassifierDefinitionId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ParameterName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.definitions.ClassifierDefinition;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.subject.feature.instance.ParameterValue;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.has.parameters.type.parameter.type.IntBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.classifier.definition.SupportedParameterValues;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.capabilities.supported.classifier.definition.SupportedParameterValuesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.supported._int.value.fields.SupportedIntValue;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.supported._int.value.fields.SupportedIntValueBuilder;
+
+import com.google.common.collect.ImmutableList;
+
+/**
+ * Match on the IP protocol of IP traffic.
+ */
+public class IpProtoClassifier extends Classifier {
+
+ protected IpProtoClassifier(Classifier parent) {
+ super(parent);
+ }
+
+ @Override
+ public ClassifierDefinitionId getId() {
+ return IpProtoClassifierDefinition.ID;
+ }
+
+ @Override
+ public ClassifierDefinition getClassifierDefinition() {
+ return IpProtoClassifierDefinition.DEFINITION;
+ }
+
+ @Override
+ public List<SupportedParameterValues> getSupportedParameterValues() {
+
+ List<SupportedIntValue> values = ImmutableList.of(
+ new SupportedIntValueBuilder().setValue(IpProtoClassifierDefinition.ICMP_VALUE).build(),
+ new SupportedIntValueBuilder().setValue(IpProtoClassifierDefinition.SCTP_VALUE).build(),
+ new SupportedIntValueBuilder().setValue(IpProtoClassifierDefinition.TCP_VALUE).build(),
+ new SupportedIntValueBuilder().setValue(IpProtoClassifierDefinition.UDP_VALUE).build());
+ SupportedParameterValuesBuilder builder = new SupportedParameterValuesBuilder();
+ builder.setParameterName(new ParameterName(IpProtoClassifierDefinition.PROTO_PARAM));
+ builder.setParameterType(new IntBuilder().setSupportedIntValue(values).build());
+
+ return ImmutableList.of(builder.build());
+ }
+
+ @Override
+ protected void checkPresenceOfRequiredParams(Map<String, ParameterValue> params) {
+ if (params.get(IpProtoClassifierDefinition.PROTO_PARAM) == null) {
+ throw new IllegalArgumentException(
+ "Parameter " + IpProtoClassifierDefinition.PROTO_PARAM + " not specified.");
+ }
+ if (params.get(IpProtoClassifierDefinition.PROTO_PARAM).getIntValue() == null) {
+ throw new IllegalArgumentException(
+ "Value of " + IpProtoClassifierDefinition.PROTO_PARAM + " parameter is not present.");
+ }
+ }
+
+ /**
+ * Return the IpProtocol value. May return null.
+ *
+ * @param params the parameters of classifier-instance inserted by user
+ * @return the IpProtocol value
+ */
+ public static Long getIpProtoValue(Map<String, ParameterValue> params) {
+ if (params == null) {
+ return null;
+ }
+ if (params.get(IpProtoClassifierDefinition.PROTO_PARAM) == null) {
+ return null;
+ }
+ Long proto = params.get(IpProtoClassifierDefinition.PROTO_PARAM).getIntValue();
+ if (proto != null) {
+ return proto;
+ }
+ return null;
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems. 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.groupbasedpolicy.renderer.vpp.util;
+
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class General {
+
+ /**
+ * Operations that can be executed over ConfigCommand. Operation names reflect operations used
+ * in WriteTransaction.
+ * For more information on these operations, please see the documentation in:
+ * <br>
+ * {@link WriteTransaction#put(LogicalDatastoreType, InstanceIdentifier, DataObject, boolean)}
+ * <br>
+ * {@link WriteTransaction#merge(LogicalDatastoreType, InstanceIdentifier, DataObject, boolean)}
+ * <br>
+ * {@link WriteTransaction#delete(LogicalDatastoreType, InstanceIdentifier)}<br>
+ */
+ public enum Operations {
+ PUT, DELETE, MERGE
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 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.groupbasedpolicy.renderer.vpp.util;
+
+import javax.annotation.Nonnull;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.MountPoint;
+import org.opendaylight.controller.md.sal.binding.api.MountPointService;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.base.Optional;
+import com.google.common.base.Preconditions;
+
+public class MountedDataBrokerProvider {
+
+ private static final Logger LOG = LoggerFactory.getLogger(MountedDataBrokerProvider.class);
+ private final MountPointService mountService;
+
+ public MountedDataBrokerProvider(@Nonnull MountPointService mountService) {
+ this.mountService = Preconditions.checkNotNull(mountService);
+ }
+
+ public Optional<DataBroker> getDataBrokerForMountPoint(@Nonnull InstanceIdentifier<?> iidToMountPoint) {
+ Optional<MountPoint> potentialMountPoint = mountService.getMountPoint(iidToMountPoint);
+ if (!potentialMountPoint.isPresent()) {
+ LOG.debug("Mount point does not exist for {}", iidToMountPoint);
+ return Optional.absent();
+ }
+ return potentialMountPoint.get().getService(DataBroker.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 Cisco Systems. 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.groupbasedpolicy.renderer.vpp.util;
+
+import org.opendaylight.groupbasedpolicy.renderer.vpp.manager.VppNodeManager;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.Renderers;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.Renderer;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.RendererKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererNodes;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.nodes.RendererNode;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.nodes.RendererNodeKey;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class VppIidFactory {
+
+ public static InstanceIdentifier<Interface> getInterfaceIID(InterfaceKey interfaceKey) {
+ return InstanceIdentifier.create(Interfaces.class).child(Interface.class, interfaceKey);
+ }
+
+ public static InstanceIdentifier<Renderer> getRendererIID(RendererKey rendererKey) {
+ return InstanceIdentifier.create(Renderers.class).child(Renderer.class, rendererKey);
+ }
+
+ public static InstanceIdentifier<RendererNodes> getRendererNodesIid() {
+ return InstanceIdentifier.builder(Renderers.class)
+ .child(Renderer.class, new RendererKey(VppNodeManager.vppRenderer))
+ .child(RendererNodes.class)
+ .build();
+ }
+
+ public static InstanceIdentifier<RendererNode> getRendererNodeIid(RendererNode rendererNode) {
+ return InstanceIdentifier.builder(Renderers.class)
+ .child(Renderer.class, new RendererKey(VppNodeManager.vppRenderer))
+ .child(RendererNodes.class)
+ .child(RendererNode.class, new RendererNodeKey(rendererNode.getNodePath()))
+ .build();
+ }
+
+ public static InstanceIdentifier<Node> getNodeIid(NodeKey key) {
+ TopologyKey topologyKey = new TopologyKey(new TopologyId("topology-netconf"));
+ return InstanceIdentifier.builder(NetworkTopology.class)
+ .child(Topology.class,topologyKey)
+ .child(Node.class, key).build();
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 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.groupbasedpolicy.renderer.vpp.util;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererNodes;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererNodesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.nodes.RendererNode;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.common.util.concurrent.CheckedFuture;
+
+public class VppNodeWriter {
+
+ private static final Logger LOG = LoggerFactory.getLogger(VppNodeWriter.class);
+ private List<RendererNode> rendererNodesCache;
+
+ public VppNodeWriter() {
+ rendererNodesCache = new ArrayList<>();
+ }
+
+ public void cache(RendererNode node) {
+ rendererNodesCache.add(node);
+ }
+
+ /**
+ * Put all cached items to data store.
+ *
+ * @param dataBroker appropriate data provider
+ */
+ public void commitToDatastore(DataBroker dataBroker) {
+ RendererNodes rendererNodes = buildRendererNodes();
+ WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
+ InstanceIdentifier<RendererNodes> iid = VppIidFactory.getRendererNodesIid();
+ try {
+ wtx.merge(LogicalDatastoreType.OPERATIONAL, iid, rendererNodes, true);
+ CheckedFuture<Void, TransactionCommitFailedException> submitFuture = wtx.submit();
+ submitFuture.checkedGet();
+ // Clear cache
+ rendererNodesCache.clear();
+ } catch (TransactionCommitFailedException e) {
+ LOG.error("Write transaction failed to {}", e.getMessage());
+ } catch (Exception e) {
+ LOG.error("Failed to .. {}", e.getMessage());
+ }
+ }
+
+ /**
+ * Removes all cached items from data store.
+ *
+ * @param dataBroker appropriate data provider
+ */
+ public void removeFromDatastore(DataBroker dataBroker) {
+ WriteTransaction wtx = dataBroker.newWriteOnlyTransaction();
+ for (RendererNode nodeToRemove : rendererNodesCache) {
+ InstanceIdentifier<RendererNode> iid = VppIidFactory.getRendererNodeIid(nodeToRemove);
+ try {
+ wtx.delete(LogicalDatastoreType.OPERATIONAL, iid);
+ CheckedFuture<Void, TransactionCommitFailedException> submitFuture = wtx.submit();
+ submitFuture.checkedGet();
+ // Clear cache
+ } catch (TransactionCommitFailedException e) {
+ LOG.error("Write transaction failed to {}", e.getMessage());
+ } catch (Exception e) {
+ LOG.error("Failed to .. {}", e.getMessage());
+ }
+ }
+ rendererNodesCache.clear();
+ }
+
+ private RendererNodes buildRendererNodes() {
+ RendererNodesBuilder rendererNodesBuilder = new RendererNodesBuilder();
+ rendererNodesBuilder.setRendererNode(new ArrayList<>(rendererNodesCache));
+ return rendererNodesBuilder.build();
+ }
+}
--- /dev/null
+module ietf-ip {
+
+ yang-version 1;
+
+ namespace
+ "urn:ietf:params:xml:ns:yang:ietf-ip";
+
+ prefix ip;
+
+ import ietf-interfaces {
+ prefix if;
+ }
+ import ietf-inet-types {
+ prefix inet;
+ }
+ import ietf-yang-types {
+ prefix yang;
+ }
+
+ organization
+ "IETF NETMOD (NETCONF Data Modeling Language) Working Group";
+
+ contact
+ "WG Web: <http://tools.ietf.org/wg/netmod/>
+ WG List: <mailto:netmod@ietf.org>
+
+ WG Chair: Thomas Nadeau
+ <mailto:tnadeau@lucidvision.com>
+
+ WG Chair: Juergen Schoenwaelder
+ <mailto:j.schoenwaelder@jacobs-university.de>
+
+ Editor: Martin Bjorklund
+ <mailto:mbj@tail-f.com>";
+
+ description
+ "This module contains a collection of YANG definitions for
+ configuring IP implementations.
+
+ Copyright (c) 2014 IETF Trust and the persons identified as
+ authors of the code. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or
+ without modification, is permitted pursuant to, and subject
+ to the license terms contained in, the Simplified BSD License
+ set forth in Section 4.c of the IETF Trust's Legal Provisions
+ Relating to IETF Documents
+ (http://trustee.ietf.org/license-info).
+
+ This version of this YANG module is part of RFC 7277; see
+ the RFC itself for full legal notices.";
+
+ revision "2014-06-16" {
+ description "Initial revision.";
+ reference
+ "RFC 7277: A YANG Data Model for IP Management";
+
+ }
+
+
+ feature ipv4-non-contiguous-netmasks {
+ description
+ "Indicates support for configuring non-contiguous
+ subnet masks.";
+ }
+
+ feature ipv6-privacy-autoconf {
+ description
+ "Indicates support for Privacy Extensions for Stateless Address
+ Autoconfiguration in IPv6.";
+ reference
+ "RFC 4941: Privacy Extensions for Stateless Address
+ Autoconfiguration in IPv6";
+
+ }
+
+ typedef ip-address-origin {
+ type enumeration {
+ enum "other" {
+ value 0;
+ description
+ "None of the following.";
+ }
+ enum "static" {
+ value 1;
+ description
+ "Indicates that the address has been statically
+ configured - for example, using NETCONF or a Command Line
+ Interface.";
+ }
+ enum "dhcp" {
+ value 2;
+ description
+ "Indicates an address that has been assigned to this
+ system by a DHCP server.";
+ }
+ enum "link-layer" {
+ value 3;
+ description
+ "Indicates an address created by IPv6 stateless
+ autoconfiguration that embeds a link-layer address in its
+ interface identifier.";
+ }
+ enum "random" {
+ value 4;
+ description
+ "Indicates an address chosen by the system at
+
+ random, e.g., an IPv4 address within 169.254/16, an
+ RFC 4941 temporary address, or an RFC 7217 semantically
+ opaque address.";
+ reference
+ "RFC 4941: Privacy Extensions for Stateless Address
+ Autoconfiguration in IPv6
+ RFC 7217: A Method for Generating Semantically Opaque
+ Interface Identifiers with IPv6 Stateless
+ Address Autoconfiguration (SLAAC)";
+
+ }
+ }
+ description
+ "The origin of an address.";
+ }
+
+ typedef neighbor-origin {
+ type enumeration {
+ enum "other" {
+ value 0;
+ description
+ "None of the following.";
+ }
+ enum "static" {
+ value 1;
+ description
+ "Indicates that the mapping has been statically
+ configured - for example, using NETCONF or a Command Line
+ Interface.";
+ }
+ enum "dynamic" {
+ value 2;
+ description
+ "Indicates that the mapping has been dynamically resolved
+ using, e.g., IPv4 ARP or the IPv6 Neighbor Discovery
+ protocol.";
+ }
+ }
+ description
+ "The origin of a neighbor entry.";
+ }
+
+ augment /if:interfaces/if:interface {
+ description
+ "Parameters for configuring IP on interfaces.
+
+ If an interface is not capable of running IP, the server
+ must not allow the client to configure these parameters.";
+ container ipv4 {
+ presence
+ "Enables IPv4 unless the 'enabled' leaf
+ (which defaults to 'true') is set to 'false'";
+ description
+ "Parameters for the IPv4 address family.";
+ leaf enabled {
+ type boolean;
+ default 'true';
+ description
+ "Controls whether IPv4 is enabled or disabled on this
+ interface. When IPv4 is enabled, this interface is
+ connected to an IPv4 stack, and the interface can send
+ and receive IPv4 packets.";
+ }
+
+ leaf forwarding {
+ type boolean;
+ default 'false';
+ description
+ "Controls IPv4 packet forwarding of datagrams received by,
+ but not addressed to, this interface. IPv4 routers
+ forward datagrams. IPv4 hosts do not (except those
+ source-routed via the host).";
+ }
+
+ leaf mtu {
+ type uint16 {
+ range "68..max";
+ }
+ units "octets";
+ description
+ "The size, in octets, of the largest IPv4 packet that the
+ interface will send and receive.
+
+ The server may restrict the allowed values for this leaf,
+ depending on the interface's type.
+
+ If this leaf is not configured, the operationally used MTU
+ depends on the interface's type.";
+ reference
+ "RFC 791: Internet Protocol";
+
+ }
+
+ list address {
+ key "ip";
+ description
+ "The list of configured IPv4 addresses on the interface.";
+ leaf ip {
+ type inet:ipv4-address-no-zone;
+ description
+ "The IPv4 address on the interface.";
+ }
+
+ choice subnet {
+ mandatory true;
+ description
+ "The subnet can be specified as a prefix-length, or,
+ if the server supports non-contiguous netmasks, as
+ a netmask.";
+ leaf prefix-length {
+ type uint8 {
+ range "0..32";
+ }
+ description
+ "The length of the subnet prefix.";
+ }
+ leaf netmask {
+ if-feature ipv4-non-contiguous-netmasks;
+ type yang:dotted-quad;
+ description
+ "The subnet specified as a netmask.";
+ }
+ } // choice subnet
+ } // list address
+
+ list neighbor {
+ key "ip";
+ description
+ "A list of mappings from IPv4 addresses to
+ link-layer addresses.
+
+ Entries in this list are used as static entries in the
+ ARP Cache.";
+ reference
+ "RFC 826: An Ethernet Address Resolution Protocol";
+
+ leaf ip {
+ type inet:ipv4-address-no-zone;
+ description
+ "The IPv4 address of the neighbor node.";
+ }
+
+ leaf link-layer-address {
+ type yang:phys-address;
+ mandatory true;
+ description
+ "The link-layer address of the neighbor node.";
+ }
+ } // list neighbor
+ } // container ipv4
+
+ container ipv6 {
+ presence
+ "Enables IPv6 unless the 'enabled' leaf
+ (which defaults to 'true') is set to 'false'";
+ description
+ "Parameters for the IPv6 address family.";
+ leaf enabled {
+ type boolean;
+ default 'true';
+ description
+ "Controls whether IPv6 is enabled or disabled on this
+ interface. When IPv6 is enabled, this interface is
+ connected to an IPv6 stack, and the interface can send
+ and receive IPv6 packets.";
+ }
+
+ leaf forwarding {
+ type boolean;
+ default 'false';
+ description
+ "Controls IPv6 packet forwarding of datagrams received by,
+ but not addressed to, this interface. IPv6 routers
+ forward datagrams. IPv6 hosts do not (except those
+ source-routed via the host).";
+ reference
+ "RFC 4861: Neighbor Discovery for IP version 6 (IPv6)
+ Section 6.2.1, IsRouter";
+
+ }
+
+ leaf mtu {
+ type uint32 {
+ range "1280..max";
+ }
+ units "octets";
+ description
+ "The size, in octets, of the largest IPv6 packet that the
+ interface will send and receive.
+
+ The server may restrict the allowed values for this leaf,
+ depending on the interface's type.
+
+ If this leaf is not configured, the operationally used MTU
+ depends on the interface's type.";
+ reference
+ "RFC 2460: Internet Protocol, Version 6 (IPv6) Specification
+ Section 5";
+
+ }
+
+ list address {
+ key "ip";
+ description
+ "The list of configured IPv6 addresses on the interface.";
+ leaf ip {
+ type inet:ipv6-address-no-zone;
+ description
+ "The IPv6 address on the interface.";
+ }
+
+ leaf prefix-length {
+ type uint8 {
+ range "0..128";
+ }
+ mandatory true;
+ description
+ "The length of the subnet prefix.";
+ }
+ } // list address
+
+ list neighbor {
+ key "ip";
+ description
+ "A list of mappings from IPv6 addresses to
+ link-layer addresses.
+
+ Entries in this list are used as static entries in the
+ Neighbor Cache.";
+ reference
+ "RFC 4861: Neighbor Discovery for IP version 6 (IPv6)";
+
+ leaf ip {
+ type inet:ipv6-address-no-zone;
+ description
+ "The IPv6 address of the neighbor node.";
+ }
+
+ leaf link-layer-address {
+ type yang:phys-address;
+ mandatory true;
+ description
+ "The link-layer address of the neighbor node.";
+ }
+ } // list neighbor
+
+ leaf dup-addr-detect-transmits {
+ type uint32;
+ default '1';
+ description
+ "The number of consecutive Neighbor Solicitation messages
+ sent while performing Duplicate Address Detection on a
+ tentative address. A value of zero indicates that
+ Duplicate Address Detection is not performed on
+ tentative addresses. A value of one indicates a single
+ transmission with no follow-up retransmissions.";
+ reference
+ "RFC 4862: IPv6 Stateless Address Autoconfiguration";
+
+ }
+
+ container autoconf {
+ description
+ "Parameters to control the autoconfiguration of IPv6
+ addresses, as described in RFC 4862.";
+ reference
+ "RFC 4862: IPv6 Stateless Address Autoconfiguration";
+
+ leaf create-global-addresses {
+ type boolean;
+ default 'true';
+ description
+ "If enabled, the host creates global addresses as
+ described in RFC 4862.";
+ reference
+ "RFC 4862: IPv6 Stateless Address Autoconfiguration
+ Section 5.5";
+
+ }
+
+ leaf create-temporary-addresses {
+ if-feature ipv6-privacy-autoconf;
+ type boolean;
+ default 'false';
+ description
+ "If enabled, the host creates temporary addresses as
+ described in RFC 4941.";
+ reference
+ "RFC 4941: Privacy Extensions for Stateless Address
+ Autoconfiguration in IPv6";
+
+ }
+
+ leaf temporary-valid-lifetime {
+ if-feature ipv6-privacy-autoconf;
+ type uint32;
+ units "seconds";
+ default '604800';
+ description
+ "The time period during which the temporary address
+ is valid.";
+ reference
+ "RFC 4941: Privacy Extensions for Stateless Address
+ Autoconfiguration in IPv6
+ - TEMP_VALID_LIFETIME";
+
+ }
+
+ leaf temporary-preferred-lifetime {
+ if-feature ipv6-privacy-autoconf;
+ type uint32;
+ units "seconds";
+ default '86400';
+ description
+ "The time period during which the temporary address is
+ preferred.";
+ reference
+ "RFC 4941: Privacy Extensions for Stateless Address
+ Autoconfiguration in IPv6
+ - TEMP_PREFERRED_LIFETIME";
+
+ }
+ } // container autoconf
+ } // container ipv6
+ }
+
+ augment /if:interfaces-state/if:interface {
+ description
+ "Data nodes for the operational state of IP on interfaces.";
+ container ipv4 {
+ presence
+ "Present if IPv4 is enabled on this interface";
+ config false;
+ description
+ "Interface-specific parameters for the IPv4 address family.";
+ leaf forwarding {
+ type boolean;
+ description
+ "Indicates whether IPv4 packet forwarding is enabled or
+ disabled on this interface.";
+ }
+
+ leaf mtu {
+ type uint16 {
+ range "68..max";
+ }
+ units "octets";
+ description
+ "The size, in octets, of the largest IPv4 packet that the
+ interface will send and receive.";
+ reference
+ "RFC 791: Internet Protocol";
+
+ }
+
+ list address {
+ key "ip";
+ description
+ "The list of IPv4 addresses on the interface.";
+ leaf ip {
+ type inet:ipv4-address-no-zone;
+ description
+ "The IPv4 address on the interface.";
+ }
+
+ choice subnet {
+ description
+ "The subnet can be specified as a prefix-length, or,
+ if the server supports non-contiguous netmasks, as
+ a netmask.";
+ leaf prefix-length {
+ type uint8 {
+ range "0..32";
+ }
+ description
+ "The length of the subnet prefix.";
+ }
+ leaf netmask {
+ if-feature ipv4-non-contiguous-netmasks;
+ type yang:dotted-quad;
+ description
+ "The subnet specified as a netmask.";
+ }
+ } // choice subnet
+
+ leaf origin {
+ type ip-address-origin;
+ description
+ "The origin of this address.";
+ }
+ } // list address
+
+ list neighbor {
+ key "ip";
+ description
+ "A list of mappings from IPv4 addresses to
+ link-layer addresses.
+
+ This list represents the ARP Cache.";
+ reference
+ "RFC 826: An Ethernet Address Resolution Protocol";
+
+ leaf ip {
+ type inet:ipv4-address-no-zone;
+ description
+ "The IPv4 address of the neighbor node.";
+ }
+
+ leaf link-layer-address {
+ type yang:phys-address;
+ description
+ "The link-layer address of the neighbor node.";
+ }
+
+ leaf origin {
+ type neighbor-origin;
+ description
+ "The origin of this neighbor entry.";
+ }
+ } // list neighbor
+ } // container ipv4
+
+ container ipv6 {
+ presence
+ "Present if IPv6 is enabled on this interface";
+ config false;
+ description
+ "Parameters for the IPv6 address family.";
+ leaf forwarding {
+ type boolean;
+ default 'false';
+ description
+ "Indicates whether IPv6 packet forwarding is enabled or
+ disabled on this interface.";
+ reference
+ "RFC 4861: Neighbor Discovery for IP version 6 (IPv6)
+ Section 6.2.1, IsRouter";
+
+ }
+
+ leaf mtu {
+ type uint32 {
+ range "1280..max";
+ }
+ units "octets";
+ description
+ "The size, in octets, of the largest IPv6 packet that the
+ interface will send and receive.";
+ reference
+ "RFC 2460: Internet Protocol, Version 6 (IPv6) Specification
+ Section 5";
+
+ }
+
+ list address {
+ key "ip";
+ description
+ "The list of IPv6 addresses on the interface.";
+ leaf ip {
+ type inet:ipv6-address-no-zone;
+ description
+ "The IPv6 address on the interface.";
+ }
+
+ leaf prefix-length {
+ type uint8 {
+ range "0..128";
+ }
+ mandatory true;
+ description
+ "The length of the subnet prefix.";
+ }
+
+ leaf origin {
+ type ip-address-origin;
+ description
+ "The origin of this address.";
+ }
+
+ leaf status {
+ type enumeration {
+ enum "preferred" {
+ value 0;
+ description
+ "This is a valid address that can appear as the
+ destination or source address of a packet.";
+ }
+ enum "deprecated" {
+ value 1;
+ description
+ "This is a valid but deprecated address that should
+ no longer be used as a source address in new
+ communications, but packets addressed to such an
+ address are processed as expected.";
+ }
+ enum "invalid" {
+ value 2;
+ description
+ "This isn't a valid address, and it shouldn't appear
+ as the destination or source address of a packet.";
+ }
+ enum "inaccessible" {
+ value 3;
+ description
+ "The address is not accessible because the interface
+ to which this address is assigned is not
+ operational.";
+ }
+ enum "unknown" {
+ value 4;
+ description
+ "The status cannot be determined for some reason.";
+ }
+ enum "tentative" {
+ value 5;
+ description
+ "The uniqueness of the address on the link is being
+ verified. Addresses in this state should not be
+ used for general communication and should only be
+ used to determine the uniqueness of the address.";
+ }
+ enum "duplicate" {
+ value 6;
+ description
+ "The address has been determined to be non-unique on
+ the link and so must not be used.";
+ }
+ enum "optimistic" {
+ value 7;
+ description
+ "The address is available for use, subject to
+ restrictions, while its uniqueness on a link is
+ being verified.";
+ }
+ }
+ description
+ "The status of an address. Most of the states correspond
+ to states from the IPv6 Stateless Address
+ Autoconfiguration protocol.";
+ reference
+ "RFC 4293: Management Information Base for the
+ Internet Protocol (IP)
+ - IpAddressStatusTC
+ RFC 4862: IPv6 Stateless Address Autoconfiguration";
+
+ }
+ } // list address
+
+ list neighbor {
+ key "ip";
+ description
+ "A list of mappings from IPv6 addresses to
+ link-layer addresses.
+
+ This list represents the Neighbor Cache.";
+ reference
+ "RFC 4861: Neighbor Discovery for IP version 6 (IPv6)";
+
+ leaf ip {
+ type inet:ipv6-address-no-zone;
+ description
+ "The IPv6 address of the neighbor node.";
+ }
+
+ leaf link-layer-address {
+ type yang:phys-address;
+ description
+ "The link-layer address of the neighbor node.";
+ }
+
+ leaf origin {
+ type neighbor-origin;
+ description
+ "The origin of this neighbor entry.";
+ }
+
+ leaf is-router {
+ type empty;
+ description
+ "Indicates that the neighbor node acts as a router.";
+ }
+
+ leaf state {
+ type enumeration {
+ enum "incomplete" {
+ value 0;
+ description
+ "Address resolution is in progress, and the link-layer
+ address of the neighbor has not yet been
+ determined.";
+ }
+ enum "reachable" {
+ value 1;
+ description
+ "Roughly speaking, the neighbor is known to have been
+ reachable recently (within tens of seconds ago).";
+ }
+ enum "stale" {
+ value 2;
+ description
+ "The neighbor is no longer known to be reachable, but
+ until traffic is sent to the neighbor no attempt
+ should be made to verify its reachability.";
+ }
+ enum "delay" {
+ value 3;
+ description
+ "The neighbor is no longer known to be reachable, and
+ traffic has recently been sent to the neighbor.
+ Rather than probe the neighbor immediately, however,
+ delay sending probes for a short while in order to
+ give upper-layer protocols a chance to provide
+ reachability confirmation.";
+ }
+ enum "probe" {
+ value 4;
+ description
+ "The neighbor is no longer known to be reachable, and
+ unicast Neighbor Solicitation probes are being sent
+ to verify reachability.";
+ }
+ }
+ description
+ "The Neighbor Unreachability Detection state of this
+ entry.";
+ reference
+ "RFC 4861: Neighbor Discovery for IP version 6 (IPv6)
+ Section 7.3.2";
+
+ }
+ } // list neighbor
+ } // container ipv6
+ }
+} // module ietf-ip
--- /dev/null
+module v3po {
+ yang-version 1;
+ namespace "urn:opendaylight:params:xml:ns:yang:v3po";
+ prefix "v3po";
+
+ revision "2015-01-05" {
+ description "Initial revision of v3po model";
+ }
+
+ import iana-if-type {
+ prefix "ianaift";
+ }
+ import ietf-interfaces {
+ prefix "if";
+ }
+ import ietf-yang-types {
+ prefix "yang";
+ }
+ import ietf-inet-types {
+ prefix "inet";
+ }
+ import ietf-ip {
+ prefix "ip";
+ }
+ import yang-ext {
+ prefix "ext";
+ }
+
+ typedef bridge-domain-ref {
+ type leafref {
+ path "/vpp/bridge-domains/bridge-domain/name";
+ }
+ description
+ "This type is used by to reference a bridge domain table";
+ }
+
+ typedef bridged-virtual-interface-ref {
+ type leafref {
+ path "/if:interfaces/if:interface/l2/bridged-virtual-interface";
+ }
+ description
+ "This type is used by to reference a bridged virtual interface";
+ }
+
+ typedef vlan-type {
+ type enumeration {
+ enum 802dot1q;
+ enum 802dot1ad;
+ }
+ }
+
+ typedef tag-rewrite-operation {
+ type enumeration {
+ enum disabled;
+ enum push-1;
+ enum push-2;
+ enum pop-1;
+ enum pop-2;
+ enum translate-1-to-1;
+ enum translate-1-to-2;
+ enum translate-2-to-1;
+ enum translate-2-to-2;
+ }
+ }
+
+ typedef vlan-tag {
+ type uint16 {
+ range "1..4094";
+ }
+ }
+
+ identity vxlan-tunnel {
+ base if:interface-type;
+ }
+
+ identity vhost-user {
+ base if:interface-type;
+ }
+
+ identity tap {
+ base if:interface-type;
+ }
+
+ identity sub-interface {
+ base if:interface-type;
+ }
+
+ typedef vxlan-vni {
+ // FIXME: should be in a vxlan-specific model
+ description "VNI used in a VXLAN tunnel";
+ type uint32 {
+ range "0..16777215";
+ }
+ }
+
+ typedef vhost-user-role {
+ type enumeration {
+ enum "server";
+ enum "client";
+ }
+ }
+
+ identity vxlan-gpe-tunnel {
+ base if:interface-type;
+ }
+
+ typedef vxlan-gpe-vni {
+ description "VNI used in a VXLAN-GPE tunnel";
+ type uint32 {
+ range "0..16777215";
+ }
+ }
+
+ typedef vxlan-gpe-next-protocol {
+ type enumeration {
+ enum ipv4;
+ enum ipv6;
+ enum ethernet;
+ enum nsh;
+ }
+ }
+
+ grouping bridge-domain-attributes {
+ leaf flood {
+ type boolean;
+ default true;
+ description
+ "Enable/disable L2 flooding.";
+ }
+ leaf forward {
+ type boolean;
+ default true;
+ description
+ "Enable/disable L2 forwarding.";
+ }
+ leaf learn {
+ type boolean;
+ default true;
+ description
+ "Enable/disable L2 learning.";
+ }
+ leaf unknown-unicast-flood {
+ type boolean;
+ default true;
+ }
+ leaf arp-termination {
+ type boolean;
+ default false;
+ }
+ }
+
+ grouping sub-interface-base-attributes {
+ leaf identifier {
+ type uint32;
+ }
+ leaf vlan-type {
+ type vlan-type;
+ default '802dot1q';
+ }
+ leaf number-of-tags {
+ type uint8 {
+ range "0..2";
+ }
+ default 1;
+ }
+ leaf outer-id {
+ type vlan-tag;
+ }
+ leaf inner-id {
+ type vlan-tag;
+ }
+ leaf match-any-outer-id {
+ type empty;
+ }
+ leaf match-any-inner-id {
+ type empty;
+ }
+ leaf exact-match {
+ type empty;
+ }
+ leaf default-subif {
+ type empty;
+ }
+ }
+
+ grouping tap-interface-base-attributes {
+ leaf tap-name {
+ type string;
+ }
+ }
+
+ grouping tap-interface-config-attributes {
+ leaf mac {
+ type yang:phys-address;
+ mandatory false;
+ description "Mac address to be set for the tap interface. Random will be used if not configured";
+ }
+
+ leaf device-instance {
+ type uint32;
+ mandatory false;
+ description "Custom device instance. Autogenerated will be used if not configured";
+ }
+ }
+
+ grouping ethernet-base-attributes {
+ leaf mtu {
+ type uint16 {
+ range "64..9216";
+ }
+ units "octets";
+ default 9216;
+ description
+ "The size, in octets, of the largest packet that the
+ hardware interface will send and receive.";
+ }
+ }
+
+ grouping ethernet-state-attributes {
+ leaf manufacturer-description {
+ type string;
+ config false;
+ }
+ leaf duplex {
+ type enumeration {
+ enum "half";
+ enum "full";
+ }
+ config false;
+ }
+ }
+
+ grouping vhost-user-interface-base-attributes {
+ leaf socket {
+ type string {
+ length 1..255;
+ }
+ }
+ leaf role {
+ type vhost-user-role;
+ default "server";
+ }
+ description "vhost-user settings";
+ }
+
+ grouping vhost-user-interface-state-attributes {
+ leaf features {
+ type uint64;
+ config false;
+ }
+ leaf virtio-net-hdr-size {
+ type uint32;
+ config false;
+ }
+ leaf num-memory-regions {
+ type uint32;
+ config false;
+ }
+ leaf connect-error {
+ type string;
+ config false;
+ }
+ }
+
+ grouping vxlan-base-attributes {
+ // FIXME: this should be in an vxlan-specific extension
+ leaf src {
+ /*mandatory true;*/
+ type inet:ip-address;
+ }
+ leaf dst {
+ /*mandatory true;*/
+ type inet:ip-address;
+ }
+ leaf vni {
+ /*mandatory true;*/
+ type vxlan-vni;
+ }
+ leaf encap-vrf-id {
+ type uint32;
+ }
+ }
+
+ grouping vxlan-gpe-base-attributes {
+ leaf local {
+ /*mandatory true;*/
+ type inet:ip-address;
+ }
+ leaf remote {
+ /*mandatory true;*/
+ type inet:ip-address;
+ }
+ leaf vni {
+ /*mandatory true;*/
+ type vxlan-gpe-vni;
+ }
+ leaf next-protocol {
+ type vxlan-gpe-next-protocol;
+ }
+ leaf encap-vrf-id {
+ type uint32;
+ }
+ leaf decap-vrf-id {
+ type uint32;
+ }
+ }
+
+ grouping vlan-tag-rewrite-attributes {
+ leaf rewrite-operation {
+ type tag-rewrite-operation;
+ default 'disabled';
+ }
+ leaf first-pushed {
+ type vlan-type;
+ default '802dot1q';
+ }
+ leaf tag1 {
+ type vlan-tag;
+ }
+ leaf tag2 {
+ type vlan-tag;
+ }
+ }
+
+ grouping l2-attributes {
+ description
+ "Parameters for configuring Layer2 features on interfaces.";
+
+ choice interconnection {
+ case xconnect-based {
+ leaf xconnect-outgoing-interface {
+ /* Don't allow selection of this interface */
+ must "../../if:name != current()";
+ type if:interface-ref; // todo use interface-state-ref for operational data?
+ description
+ "L2 xconnect mode";
+ }
+ }
+ case bridge-based {
+ leaf bridge-domain {
+ type bridge-domain-ref;
+ description
+ "Interfaces in a bridge-domain forward packets to other
+ interfaces in the same bridge-domain based on
+ destination mac address.";
+ }
+ leaf split-horizon-group {
+ when "../bridge-domain";
+ type uint8 {
+ range "0..255";
+ }
+ default 0;
+ description
+ "Interface's split-horizon group. Interfaces in the same
+ bridge-domain and split-horizon group can not forward
+ packets between each other. ";
+ }
+ leaf bridged-virtual-interface {
+ when "../bridge-domain";
+ type boolean;
+ default false;
+ description
+ "Interface forward packets in the bridge-domain
+ associated with the BVI.";
+ }
+ }
+ }
+ container vlan-tag-rewrite { // todo valid only for sub-interfaces
+ uses vlan-tag-rewrite-attributes;
+ }
+ }
+
+ augment /if:interfaces/if:interface {
+ ext:augment-identifier "vpp-interface-augmentation";
+
+ // FIXME using ietf-interfaces model for vpp interfaces makes it hard to implement because:
+ // 1. The link between interface type and this augmentation is unclear
+ // 2. Only this augmentation with combination of ifc type is trigger to do something for vpp, what if user only configures base interface stuff ? + We need to get leaves defined by ietf-interfaces when we are processing this augment
+ // 3. The ietf-interfaces model does not define groupings which makes types reuse difficult
+
+ container sub-interface {
+ when "../if:type = 'v3po:sub-interface'";
+ leaf super-interface {
+ type if:interface-ref;
+ }
+ uses sub-interface-base-attributes;
+ }
+
+ container tap {
+ when "../if:type = 'v3po:tap'";
+ uses tap-interface-base-attributes;
+ uses tap-interface-config-attributes;
+ }
+
+ container ethernet {
+ when "../if:type = 'ianaift:ethernetCsmacd'";
+ uses ethernet-base-attributes;
+ }
+
+ container routing {
+ leaf vrf-id { // todo no routing info for oper, is it possible to get it from the vpp?
+ type uint32;
+ default 0;
+ }
+ }
+
+ container vhost-user {
+ when "../if:type = 'v3po:vhost-user'";
+ uses vhost-user-interface-base-attributes;
+ }
+
+ container vxlan {
+ when "../if:type = 'v3po:vxlan-tunnel'";
+ uses vxlan-base-attributes;
+ }
+
+ container l2 {
+ must "(not (../if:ipv4[if:enabled = 'true']/if:address/if:ip) and " +
+ "not (../if:ipv6[if:enabled = 'true']/if:address/if:ip))";
+
+ uses l2-attributes;
+ }
+
+ container vxlan-gpe {
+ when "../if:type = 'v3po:vxlan-gpe-tunnel'";
+
+ uses vxlan-gpe-base-attributes;
+ }
+ }
+
+ container vpp {
+ description
+ "VPP config data";
+
+ container bridge-domains {
+ list bridge-domain {
+ key "name";
+ // TODO: where does this come from?
+ max-elements 1024;
+
+ leaf name {
+ type string;
+ }
+
+ uses bridge-domain-attributes;
+
+ list l2-fib {
+ key "phys-address";
+
+ leaf phys-address {
+ type yang:phys-address;
+ }
+ leaf action {
+ type enumeration {
+ enum "forward";
+ enum "filter";
+ }
+ mandatory true;
+ }
+ leaf outgoing-interface {
+ type if:interface-ref;
+ }
+ }
+ }
+ }
+ }
+
+ augment /if:interfaces-state/if:interface {
+ ext:augment-identifier "vpp-interface-state-augmentation";
+
+ leaf description {
+ type string;
+ }
+
+ container sub-interface {
+ when "../if:type = 'v3po:sub-interface'";
+ leaf super-interface {
+ type if:interface-state-ref;
+ }
+ uses sub-interface-base-attributes;
+ }
+
+ container tap {
+ when "../if:type = 'v3po:tap'";
+ uses tap-interface-base-attributes;
+ }
+
+ container ethernet {
+ when "../if:type = 'ianaift:ethernetCsmacd'";
+ uses ethernet-base-attributes;
+ uses ethernet-state-attributes;
+ }
+
+ container vhost-user {
+ when "../if:type = 'v3po:vhost-user'";
+ uses vhost-user-interface-base-attributes;
+ uses vhost-user-interface-state-attributes;
+ }
+
+ container vxlan {
+ when "../if:type = 'v3po:vxlan-tunnel'";
+ uses vxlan-base-attributes;
+ }
+ container vxlan-gpe {
+ when "../if:type = 'v3po:vxlan-gpe-tunnel'";
+
+ uses vxlan-gpe-base-attributes;
+ }
+
+ container l2 {
+ must "(not (../if:ipv4[if:enabled = 'true']/if:address/if:ip) and " +
+ "not (../if:ipv6[if:enabled = 'true']/if:address/if:ip))";
+
+ uses l2-attributes;
+ }
+ }
+
+ augment /if:interfaces-state/if:interface/if:statistics {
+ ext:augment-identifier "vpp-interface-statistics-augmentation";
+ leaf in-errors-no-buf {
+ type yang:counter64;
+ }
+ leaf in-errors-miss {
+ type yang:counter64;
+ }
+ leaf out-discards-fifo-full {
+ type yang:counter64;
+ }
+ }
+
+ container vpp-state {
+ config false;
+
+ description
+ "VPP operational data";
+
+ container bridge-domains {
+ // FIXME: Should this live in bridge-domain.yang in a modular fashion ?
+ list bridge-domain {
+
+ key "name";
+ leaf name {
+ type string;
+ }
+
+ uses bridge-domain-attributes;
+
+ list interface {
+ key "name";
+
+ leaf name {
+ type if:interface-state-ref;
+ }
+
+ leaf split-horizon-group {
+ type uint8;
+ }
+
+ leaf bridged-virtual-interface {
+ type boolean;
+ }
+ }
+
+ list l2-fib {
+ key "phys-address";
+
+ leaf phys-address {
+ type yang:phys-address;
+ }
+ leaf static-config {
+ type boolean;
+ }
+ leaf outgoing-interface {
+ when "../v3po:action = 'forward'";
+ type if:interface-state-ref;
+ }
+ leaf action {
+ type enumeration {
+ enum "forward";
+ enum "filter";
+ }
+ mandatory true;
+ }
+ leaf bridged-virtual-interface {
+ when "../v3po:action = 'forward'";
+ type boolean;
+ }
+ }
+ description
+ "bridge-domain operational data";
+ }
+ }
+
+ container version {
+ leaf name {
+ type string;
+ }
+ leaf build-directory {
+ type string;
+ }
+ leaf build-date {
+ type string;
+ }
+ leaf branch {
+ type string;
+ }
+ description
+ "vlib version info";
+ }
+ }
+}
identity vpp-provider-impl {
base "config:module-type";
- config:java-name-prefix VppProvider;
+ config:java-name-prefix GbpVppProvider;
}
// Augments the 'configuration' choice node under modules/module.
}
}
}
+ // binding aware broker
+ container broker {
+ uses config:service-ref {
+ refine type {
+ mandatory true;
+ config:required-identity mdsal:binding-broker-osgi-registry;
+ }
+ }
+ }
}
}
}
--- /dev/null
+/*
+ * Copyright (c) 2016 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
+ */
+
+module vpp-renderer {
+ yang-version 1;
+
+ namespace "urn:opendaylight:groupbasedpolicy:vpp_renderer";
+ prefix "vpp-renderer";
+
+ import base-endpoint { prefix base-ep; revision-date 2016-04-27; }
+
+ description
+ "This module is a baseline for the group-based policy vpp renderer model.";
+
+ revision "2016-04-25" {
+ description
+ "Initial revision.";
+ }
+
+ container config {
+ list vpp-endpoint {
+ description "Renderer creates/removes interface on VPP node based on given parameters.";
+
+ key "context-type context-id address-type address";
+ uses base-ep:address-endpoint-key;
+
+ leaf vpp-node-path {
+ description "Path to a node representing mount-point to VPP instance.";
+ type instance-identifier;
+ }
+ leaf vpp-interface-name {
+ description "Name of interface for the endpoint on VPP";
+ type string;
+ }
+ leaf description {
+ description "Additional description of the vpp-endpoint";
+ type string;
+ }
+ choice interface-type-choice {
+ case vhost-user-case {
+ leaf socket {
+ description "A unique ID for the neutron port";
+ type string {
+ length 1..255;
+ }
+ }
+ }
+ }
+ }
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 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.groupbasedpolicy.renderer.vpp;
+
+import static com.google.common.base.Preconditions.checkState;
+
+import java.io.IOException;
+import java.util.Collection;
+
+import javax.annotation.Nonnull;
+
+import org.opendaylight.controller.md.sal.binding.test.AbstractDataBrokerTest;
+import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
+import org.opendaylight.yangtools.yang.binding.util.BindingReflections;
+
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.ImmutableSet.Builder;
+
+/**
+ * Loads only modules of GBP and it's dependencies for data broker.
+ * <br>
+ * Therefore this implementation is faster than {@link AbstractDataBrokerTest}
+ */
+public abstract class CustomDataBrokerTest extends AbstractDataBrokerTest {
+
+ public static void loadModuleInfos(Class<?> clazzFromModule, Builder<YangModuleInfo> moduleInfoSet)
+ throws Exception {
+ YangModuleInfo moduleInfo = BindingReflections.getModuleInfo(clazzFromModule);
+ checkState(moduleInfo != null, "Module Info for %s is not available.", clazzFromModule);
+ collectYangModuleInfo(moduleInfo, moduleInfoSet);
+ }
+
+ private static void collectYangModuleInfo(final YangModuleInfo moduleInfo,
+ final Builder<YangModuleInfo> moduleInfoSet) throws IOException {
+ moduleInfoSet.add(moduleInfo);
+ for (YangModuleInfo dependency : moduleInfo.getImportedModules()) {
+ collectYangModuleInfo(dependency, moduleInfoSet);
+ }
+ }
+
+ @Override
+ protected Iterable<YangModuleInfo> getModuleInfos() throws Exception {
+ Builder<YangModuleInfo> moduleInfoSet = ImmutableSet.<YangModuleInfo>builder();
+ for (Class<?> clazz : getClassesFromModules()) {
+ loadModuleInfos(clazz, moduleInfoSet);
+ }
+ return moduleInfoSet.build();
+ }
+
+ /**
+ * @return a class from every yang module which needs to be loaded. Cannot return {@code null}
+ * or empty collection.
+ */
+ public abstract @Nonnull Collection<Class<?>> getClassesFromModules();
+}
--- /dev/null
+/*\r
+ * Copyright (c) 2016 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
+package org.opendaylight.groupbasedpolicy.renderer.vpp;\r
+\r
+import com.google.common.collect.ImmutableList;\r
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;\r
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.Renderer;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNode;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.interfaces._interface.VhostUser;\r
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;\r
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;\r
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;\r
+\r
+import javax.annotation.Nonnull;\r
+import java.util.Collection;\r
+\r
+public class VppRendererDataBrokerTest extends CustomDataBrokerTest {\r
+\r
+ @Nonnull\r
+ @Override\r
+ public Collection<Class<?>> getClassesFromModules() {\r
+ return ImmutableList.of(Interfaces.class, Interface.class, VhostUser.class, NetworkTopology.class,\r
+ Topology.class, Node.class, NetconfNode.class, Renderer.class);\r
+ }\r
+}\r
--- /dev/null
+/*\r
+ * Copyright (c) 2016 Cisco Systems. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+\r
+package org.opendaylight.groupbasedpolicy.renderer.vpp.commands;\r
+\r
+import org.junit.Assert;\r
+import org.junit.Before;\r
+import org.junit.Test;\r
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;\r
+import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;\r
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
+import org.opendaylight.groupbasedpolicy.renderer.vpp.VppRendererDataBrokerTest;\r
+import org.opendaylight.groupbasedpolicy.renderer.vpp.util.General;\r
+import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory;\r
+import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;\r
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;\r
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VhostUserRole;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VppInterfaceAugmentation;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VppInterfaceAugmentationBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.interfaces._interface.L2Builder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.interfaces._interface.VhostUser;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.interfaces._interface.VhostUserBuilder;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.l2.attributes.interconnection.BridgeBased;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.l2.attributes.interconnection.BridgeBasedBuilder;\r
+\r
+import com.google.common.base.Optional;\r
+\r
+public class VhostUserCommandTest extends VppRendererDataBrokerTest {\r
+\r
+ private final static String BRIDGE_DOMAIN = "testBD";\r
+ private final static String DESCRIPTION = "used for testing";\r
+ private final static String INTERFACE_NAME = "testInterface";\r
+ private final static String SOCKET_NAME = "soc1";\r
+\r
+ private final static String UPD_BRIDGE_DOMAIN = "testBD2";\r
+ private final static String UPD_DESCRIPTION = "updated description";\r
+ private final static String UPD_SOCKET_NAME = "soc2";\r
+ private final static short SPLIT_HORIZON_GROUP_DEFAULT = 0;\r
+ private final static boolean IS_BRIDGED_DEFAULT = false;\r
+\r
+ private static Interface BASIC_INTERFACE;\r
+\r
+ private DataBroker dataBroker;\r
+\r
+ @Before\r
+ public void init() {\r
+ dataBroker = getDataBroker();\r
+\r
+ VhostUser vhostUser = new VhostUserBuilder().setRole(VhostUserRole.Server).setSocket(SOCKET_NAME).build();\r
+\r
+ VppInterfaceAugmentation vppAugmentation = new VppInterfaceAugmentationBuilder().setVhostUser(vhostUser)\r
+ .setL2(new L2Builder().setInterconnection(new BridgeBasedBuilder().setBridgeDomain(BRIDGE_DOMAIN)\r
+ .setSplitHorizonGroup(SPLIT_HORIZON_GROUP_DEFAULT)\r
+ .setBridgedVirtualInterface(IS_BRIDGED_DEFAULT)\r
+ .build()).build())\r
+ .build();\r
+\r
+ BASIC_INTERFACE =\r
+ new InterfaceBuilder().setDescription(DESCRIPTION)\r
+ .setEnabled(true)\r
+ .setKey(new InterfaceKey(INTERFACE_NAME))\r
+ .setName(INTERFACE_NAME)\r
+ .setType(\r
+ org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VhostUser.class)\r
+ .setLinkUpDownTrapEnable(Interface.LinkUpDownTrapEnable.Enabled)\r
+ .addAugmentation(VppInterfaceAugmentation.class, vppAugmentation)\r
+ .build();\r
+ }\r
+\r
+ @Test\r
+ public void AddVhostTest() {\r
+ ReadWriteTransaction transaction = dataBroker.newReadWriteTransaction();\r
+ VhostUserCommand addCommand = VhostUserCommand.builder()\r
+ .setOperation(General.Operations.PUT)\r
+ .setName(INTERFACE_NAME)\r
+ .setDescription(DESCRIPTION)\r
+ .setRole(VhostUserRole.Server)\r
+ .setSocket(SOCKET_NAME)\r
+ .setBridgeDomain(BRIDGE_DOMAIN)\r
+ .setEnabled(true)\r
+ .build();\r
+\r
+ addCommand.execute(transaction);\r
+\r
+ transaction.submit();\r
+\r
+ ReadOnlyTransaction readOnlyTransaction = dataBroker.newReadOnlyTransaction();\r
+\r
+ Optional<Interface> optional = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,\r
+ VppIidFactory.getInterfaceIID(new InterfaceKey(INTERFACE_NAME)), readOnlyTransaction);\r
+\r
+ Assert.assertTrue("Interface was not written to DS", optional.isPresent());\r
+\r
+ Interface anInterface = optional.get();\r
+\r
+ Assert.assertEquals(BASIC_INTERFACE, anInterface);\r
+\r
+ }\r
+\r
+ @Test\r
+ public void DeleteVhostTest() {\r
+ ReadWriteTransaction transaction = dataBroker.newReadWriteTransaction();\r
+\r
+ transaction.put(LogicalDatastoreType.CONFIGURATION, VppIidFactory.getInterfaceIID(BASIC_INTERFACE.getKey()),\r
+ BASIC_INTERFACE, true);\r
+ transaction.submit();\r
+\r
+ Optional<Interface> optional = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,\r
+ VppIidFactory.getInterfaceIID(BASIC_INTERFACE.getKey()), dataBroker.newReadOnlyTransaction());\r
+\r
+ Assert.assertTrue("Interface was not written to DS", optional.isPresent());\r
+\r
+ VhostUserCommand deleteCommand = VhostUserCommand.builder()\r
+ .setOperation(General.Operations.DELETE)\r
+ .setName(INTERFACE_NAME)\r
+ .setSocket(SOCKET_NAME)\r
+ .build();\r
+\r
+ ReadWriteTransaction deleteTransaction = dataBroker.newReadWriteTransaction();\r
+ deleteCommand.execute(deleteTransaction);\r
+ deleteTransaction.submit();\r
+\r
+ Optional<Interface> optionalDeleted = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,\r
+ VppIidFactory.getInterfaceIID(new InterfaceKey(deleteCommand.getName())),\r
+ dataBroker.newReadOnlyTransaction());\r
+\r
+ Assert.assertFalse("Interface was not deleted from DS", optionalDeleted.isPresent());\r
+ }\r
+\r
+ @Test\r
+ public void UpdateVhostTest() {\r
+ ReadWriteTransaction transaction = dataBroker.newReadWriteTransaction();\r
+\r
+ transaction.put(LogicalDatastoreType.CONFIGURATION, VppIidFactory.getInterfaceIID(BASIC_INTERFACE.getKey()),\r
+ BASIC_INTERFACE, true);\r
+ transaction.submit();\r
+\r
+ Optional<Interface> optional = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,\r
+ VppIidFactory.getInterfaceIID(BASIC_INTERFACE.getKey()), dataBroker.newReadOnlyTransaction());\r
+\r
+ Assert.assertTrue("Interface was not written to DS", optional.isPresent());\r
+\r
+ VhostUserCommand updateCommand = VhostUserCommand.builder()\r
+ .setOperation(General.Operations.MERGE)\r
+ .setName(INTERFACE_NAME)\r
+ .setDescription(UPD_DESCRIPTION)\r
+ .setEnabled(false)\r
+ .setRole(VhostUserRole.Client)\r
+ .setSocket(UPD_SOCKET_NAME)\r
+ .setBridgeDomain(UPD_BRIDGE_DOMAIN)\r
+ .build();\r
+\r
+ ReadWriteTransaction deleteTransaction = dataBroker.newReadWriteTransaction();\r
+ updateCommand.execute(deleteTransaction);\r
+ deleteTransaction.submit();\r
+\r
+ Optional<Interface> optionalUpdated = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,\r
+ VppIidFactory.getInterfaceIID(new InterfaceKey(updateCommand.getName())),\r
+ dataBroker.newReadOnlyTransaction());\r
+\r
+ Assert.assertTrue("Interface was not found in DS", optionalUpdated.isPresent());\r
+ Interface updatedInterface = optionalUpdated.get();\r
+\r
+ Assert.assertEquals(UPD_DESCRIPTION, updatedInterface.getDescription());\r
+ Assert.assertFalse(updatedInterface.isEnabled());\r
+ VppInterfaceAugmentation vppInterfaceAugmentation =\r
+ updatedInterface.getAugmentation(VppInterfaceAugmentation.class);\r
+ Assert.assertEquals(VhostUserRole.Client, vppInterfaceAugmentation.getVhostUser().getRole());\r
+ Assert.assertEquals(UPD_SOCKET_NAME, vppInterfaceAugmentation.getVhostUser().getSocket());\r
+\r
+ Assert.assertTrue(vppInterfaceAugmentation.getL2().getInterconnection() instanceof BridgeBased);\r
+\r
+ Assert.assertEquals(UPD_BRIDGE_DOMAIN,\r
+ ((BridgeBased) vppInterfaceAugmentation.getL2().getInterconnection()).getBridgeDomain());\r
+ }\r
+}\r
--- /dev/null
+/*
+ * Copyright (c) 2016 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.groupbasedpolicy.renderer.vpp.event;
+
+import org.junit.Assert;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class DtoChangeEventTest {
+
+ private final static TopologyKey TOPO_KEY = new TopologyKey(new TopologyId("topo1"));
+ private final static NodeKey NODE_KEY = new NodeKey(new NodeId("node1"));
+ private final static InstanceIdentifier<Node> NODE_IID = InstanceIdentifier.builder(NetworkTopology.class)
+ .child(Topology.class, TOPO_KEY)
+ .child(Node.class, NODE_KEY)
+ .build();
+
+ @Rule
+ public ExpectedException thrown = ExpectedException.none();
+
+ private static class DummyDtoEvent extends DtoChangeEvent<Node> {
+
+ public DummyDtoEvent(InstanceIdentifier<Node> iid, Node before, Node after) {
+ super(iid, before, after);
+ }
+ }
+
+ @Test
+ public void testConstructor_nodeCreated() {
+ Node node = new NodeBuilder().setKey(NODE_KEY).build();
+ DummyDtoEvent event = new DummyDtoEvent(NODE_IID, null, node);
+ Assert.assertNotNull(event.getIid());
+ Assert.assertTrue(event.getAfter().isPresent());
+ Assert.assertFalse(event.getBefore().isPresent());
+ Assert.assertEquals(DtoChangeEvent.DtoModificationType.CREATED, event.getDtoModificationType());
+ Assert.assertTrue(event.isDtoCreated());
+ Assert.assertFalse(event.isDtoDeleted());
+ Assert.assertFalse(event.isDtoUpdated());
+ }
+
+ @Test
+ public void testConstructor_nodeDeleted() {
+ Node node = new NodeBuilder().setKey(NODE_KEY).build();
+ DummyDtoEvent event = new DummyDtoEvent(NODE_IID, node, null);
+ Assert.assertNotNull(event.getIid());
+ Assert.assertFalse(event.getAfter().isPresent());
+ Assert.assertTrue(event.getBefore().isPresent());
+ Assert.assertEquals(DtoChangeEvent.DtoModificationType.DELETED, event.getDtoModificationType());
+ Assert.assertFalse(event.isDtoCreated());
+ Assert.assertTrue(event.isDtoDeleted());
+ Assert.assertFalse(event.isDtoUpdated());
+ }
+
+ @Test
+ public void testConstructor_nodeUpdated() {
+ Node node = new NodeBuilder().setKey(NODE_KEY).build();
+ DummyDtoEvent event = new DummyDtoEvent(NODE_IID, node, node);
+ Assert.assertNotNull(event.getIid());
+ Assert.assertTrue(event.getAfter().isPresent());
+ Assert.assertTrue(event.getBefore().isPresent());
+ Assert.assertEquals(DtoChangeEvent.DtoModificationType.UPDATED, event.getDtoModificationType());
+ Assert.assertFalse(event.isDtoCreated());
+ Assert.assertFalse(event.isDtoDeleted());
+ Assert.assertTrue(event.isDtoUpdated());
+ }
+
+ @Test
+ public void testConstructor_nullNodes_Exception() {
+ thrown.expect(IllegalArgumentException.class);
+ new DummyDtoEvent(NODE_IID, null, null);
+ }
+
+ @Test
+ public void testConstructor_nullIid_Exception() {
+ Node node = new NodeBuilder().setKey(NODE_KEY).build();
+ thrown.expect(NullPointerException.class);
+ new DummyDtoEvent(null, node, node);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 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.groupbasedpolicy.renderer.vpp.event;
+
+import org.junit.Assert;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNode;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus.ConnectionStatus;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class NodeOperEventTest {
+
+ private final static TopologyKey TOPO_KEY = new TopologyKey(new TopologyId("topo1"));
+ private final static NodeKey NODE_KEY = new NodeKey(new NodeId("node1"));
+ private final static InstanceIdentifier<Node> NODE_IID = InstanceIdentifier.builder(NetworkTopology.class)
+ .child(Topology.class, TOPO_KEY)
+ .child(Node.class, NODE_KEY)
+ .build();
+ private final static NetconfNode NETCONF_NODE_AUG_CONNECTED =
+ new NetconfNodeBuilder().setConnectionStatus(ConnectionStatus.Connected).build();
+ private final static NetconfNode NETCONF_NODE_AUG_CONNECTING =
+ new NetconfNodeBuilder().setConnectionStatus(ConnectionStatus.Connecting).build();
+
+ @Rule
+ public ExpectedException thrown = ExpectedException.none();
+
+ @Test
+ public void testConstructor_nodeCreated() {
+ Node node = new NodeBuilder().setKey(NODE_KEY)
+ .addAugmentation(NetconfNode.class, NETCONF_NODE_AUG_CONNECTED)
+ .build();
+ NodeOperEvent event = new NodeOperEvent(NODE_IID, null, node);
+ Assert.assertTrue(event.getAfter().isPresent());
+ Assert.assertFalse(event.getBefore().isPresent());
+ }
+
+ @Test
+ public void testConstructor_nodeDeleted() {
+ Node node = new NodeBuilder().setKey(NODE_KEY)
+ .addAugmentation(NetconfNode.class, NETCONF_NODE_AUG_CONNECTED)
+ .build();
+ NodeOperEvent event = new NodeOperEvent(NODE_IID, node, null);
+ Assert.assertFalse(event.getAfter().isPresent());
+ Assert.assertTrue(event.getBefore().isPresent());
+ }
+
+ @Test
+ public void testConstructor_nodeUpdated() {
+ Node node = new NodeBuilder().setKey(NODE_KEY)
+ .addAugmentation(NetconfNode.class, NETCONF_NODE_AUG_CONNECTED)
+ .build();
+ NodeOperEvent event = new NodeOperEvent(NODE_IID, node, node);
+ Assert.assertTrue(event.getAfter().isPresent());
+ Assert.assertTrue(event.getBefore().isPresent());
+ }
+
+ @Test
+ public void testConstructor_beforeNodeMissingNetconfNodeAug_Exception() {
+ Node node = new NodeBuilder().setKey(NODE_KEY).build();
+ thrown.expect(IllegalArgumentException.class);
+ new NodeOperEvent(NODE_IID, node, null);
+ }
+
+ @Test
+ public void testConstructor_afterNodeMissingNetconfNodeAug_Exception() {
+ Node node = new NodeBuilder().setKey(NODE_KEY).build();
+ thrown.expect(IllegalArgumentException.class);
+ new NodeOperEvent(NODE_IID, null, node);
+ }
+
+ @Test
+ public void testConstructor_nullNodes_Exception() {
+ thrown.expect(IllegalArgumentException.class);
+ new NodeOperEvent(NODE_IID, null, null);
+ }
+
+ @Test
+ public void testConstructor_nullIid_Exception() {
+ Node node = new NodeBuilder().setKey(NODE_KEY)
+ .addAugmentation(NetconfNode.class, NETCONF_NODE_AUG_CONNECTED)
+ .build();
+ thrown.expect(NullPointerException.class);
+ new NodeOperEvent(null, node, node);
+ }
+
+ @Test
+ public void testIsAfterConnected() {
+ Node node = new NodeBuilder().setKey(NODE_KEY)
+ .addAugmentation(NetconfNode.class, NETCONF_NODE_AUG_CONNECTED)
+ .build();
+ NodeOperEvent event = new NodeOperEvent(NODE_IID, null, node);
+ Assert.assertTrue(event.isAfterConnected());
+ }
+
+ @Test
+ public void testIsBeforeConnected() {
+ Node node = new NodeBuilder().setKey(NODE_KEY)
+ .addAugmentation(NetconfNode.class, NETCONF_NODE_AUG_CONNECTED)
+ .build();
+ NodeOperEvent event = new NodeOperEvent(NODE_IID, node, null);
+ Assert.assertTrue(event.isBeforeConnected());
+ }
+
+ @Test
+ public void testIsAfterConnected_false() {
+ Node node = new NodeBuilder().setKey(NODE_KEY)
+ .addAugmentation(NetconfNode.class, NETCONF_NODE_AUG_CONNECTING)
+ .build();
+ NodeOperEvent event = new NodeOperEvent(NODE_IID, null, node);
+ Assert.assertFalse(event.isAfterConnected());
+ }
+
+ @Test
+ public void testIsBeforeConnected_false() {
+ Node node = new NodeBuilder().setKey(NODE_KEY)
+ .addAugmentation(NetconfNode.class, NETCONF_NODE_AUG_CONNECTING)
+ .build();
+ NodeOperEvent event = new NodeOperEvent(NODE_IID, null, node);
+ Assert.assertFalse(event.isBeforeConnected());
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 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.groupbasedpolicy.renderer.vpp.event;
+
+import org.junit.Assert;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContextId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.AddressType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.ContextType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.Config;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpointBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpointKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+public class VppEndpointConfEventTest {
+
+ private final static String ADDRESS = "1.1.1.1/32";
+ private final static ContextId CONTEXT_ID = new ContextId("ctx1");
+ private final static VppEndpointKey BASIC_VPP_EP_KEY =
+ new VppEndpointKey(ADDRESS, AddressType.class, CONTEXT_ID, ContextType.class);
+ private final static InstanceIdentifier<VppEndpoint> BASIC_VPP_EP_IID =
+ InstanceIdentifier.builder(Config.class).child(VppEndpoint.class, BASIC_VPP_EP_KEY).build();
+
+ @Rule
+ public ExpectedException thrown = ExpectedException.none();
+
+ @Test
+ public void testConstructor_vppEpCreated() {
+ VppEndpoint vppEndpoint = basicVppEpBuilder().build();
+ VppEndpointConfEvent event = new VppEndpointConfEvent(BASIC_VPP_EP_IID, null, vppEndpoint);
+ Assert.assertTrue(event.getAfter().isPresent());
+ Assert.assertFalse(event.getBefore().isPresent());
+ }
+
+ @Test
+ public void testConstructor_vppEpDeleted() {
+ VppEndpoint vppEndpoint = basicVppEpBuilder().build();
+ VppEndpointConfEvent event = new VppEndpointConfEvent(BASIC_VPP_EP_IID, vppEndpoint, null);
+ Assert.assertFalse(event.getAfter().isPresent());
+ Assert.assertTrue(event.getBefore().isPresent());
+ }
+
+ @Test
+ public void testConstructor_vppEpUpdated() {
+ VppEndpoint vppEndpoint = basicVppEpBuilder().build();
+ VppEndpointConfEvent event = new VppEndpointConfEvent(BASIC_VPP_EP_IID, vppEndpoint, vppEndpoint);
+ Assert.assertTrue(event.getAfter().isPresent());
+ Assert.assertTrue(event.getBefore().isPresent());
+ }
+
+ @Test
+ public void testConstructor_nullVppEp_Exception() {
+ thrown.expect(IllegalArgumentException.class);
+ new VppEndpointConfEvent(BASIC_VPP_EP_IID, null, null);
+ }
+
+ private VppEndpointBuilder basicVppEpBuilder() {
+ return new VppEndpointBuilder().setAddress(ADDRESS)
+ .setAddressType(AddressType.class)
+ .setContextId(CONTEXT_ID)
+ .setContextType(ContextType.class);
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 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.groupbasedpolicy.renderer.vpp.iface;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.event.VppEndpointConfEvent;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.util.MountedDataBrokerProvider;
+import org.opendaylight.groupbasedpolicy.test.CustomDataBrokerTest;
+import org.opendaylight.groupbasedpolicy.util.IidFactory;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.Interfaces;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.Interface;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.interfaces.rev140508.interfaces.InterfaceKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContextId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.LocationProviders;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.LocationProvider;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.location.providers.location.provider.ProviderAddressEndpointLocation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.AddressType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.ContextType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.Config;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpointBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpointKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.vpp.endpoint._interface.type.choice.VhostUserCaseBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VhostUser;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VhostUserRole;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.VppInterfaceAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.interfaces._interface.L2;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.l2.attributes.Interconnection;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.l2.attributes.interconnection.BridgeBased;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.vpp.BridgeDomains;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NetworkTopology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.TopologyId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.Topology;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.TopologyKey;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import com.google.common.base.Optional;
+import com.google.common.base.Strings;
+
+public class InterfaceManagerTest extends CustomDataBrokerTest {
+
+ private final static String ADDRESS = "1.1.1.1/32";
+ private final static ContextId CONTEXT_ID = new ContextId("ctx1");
+ private final static String IFACE_NAME = "ifaceName1";
+ private final static VppEndpointKey BASIC_VPP_EP_KEY =
+ new VppEndpointKey(ADDRESS, AddressType.class, CONTEXT_ID, ContextType.class);
+ private final static InstanceIdentifier<VppEndpoint> BASIC_VPP_EP_IID =
+ InstanceIdentifier.builder(Config.class).child(VppEndpoint.class, BASIC_VPP_EP_KEY).build();
+ private final static TopologyKey TOPO_KEY = new TopologyKey(new TopologyId("topo1"));
+ private final static NodeKey NODE_KEY = new NodeKey(new NodeId("node1"));
+ private final static InstanceIdentifier<Node> NODE_IID = InstanceIdentifier.builder(NetworkTopology.class)
+ .child(Topology.class, TOPO_KEY)
+ .child(Node.class, NODE_KEY)
+ .build();
+ private final static String SOCKET = "socket1";
+
+ private InterfaceManager manager;
+ private MountedDataBrokerProvider mountedDataProviderMock;
+ private DataBroker mountPointDataBroker;
+ private DataBroker dataBroker;
+
+ @Override
+ public Collection<Class<?>> getClassesFromModules() {
+ return Arrays.asList(Node.class, VppEndpoint.class, Interfaces.class, BridgeDomains.class,
+ LocationProviders.class);
+ }
+
+ @Before
+ public void init() throws Exception {
+ mountedDataProviderMock = Mockito.mock(MountedDataBrokerProvider.class);
+ mountPointDataBroker = getDataBroker();
+ setup(); // initialize new data broker for ODL data store
+ dataBroker = getDataBroker();
+ Mockito.when(mountedDataProviderMock.getDataBrokerForMountPoint(Mockito.any(InstanceIdentifier.class)))
+ .thenReturn(Optional.of(mountPointDataBroker));
+ manager = new InterfaceManager(mountedDataProviderMock, dataBroker);
+ }
+
+ @Test
+ public void testVppEndpointChanged_created() throws Exception {
+ VppEndpoint vhostEp = vhostVppEpBuilder().build();
+ VppEndpointConfEvent event = new VppEndpointConfEvent(BASIC_VPP_EP_IID, null, vhostEp);
+
+ manager.vppEndpointChanged(event);
+ // assert state on data store behind mount point
+ ReadOnlyTransaction rTxMount = mountPointDataBroker.newReadOnlyTransaction();
+ Optional<Interface> potentialIface =
+ rTxMount.read(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.builder(Interfaces.class)
+ .child(Interface.class, new InterfaceKey(vhostEp.getVppInterfaceName()))
+ .build()).get();
+ Assert.assertTrue(potentialIface.isPresent());
+ Interface iface = potentialIface.get();
+ Assert.assertEquals(VhostUser.class, iface.getType());
+ Assert.assertTrue(iface.isEnabled());
+ VppInterfaceAugmentation vppIface = iface.getAugmentation(VppInterfaceAugmentation.class);
+ Assert.assertNotNull(vppIface);
+ org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.v3po.rev150105.interfaces._interface.VhostUser vhostUserIface =
+ vppIface.getVhostUser();
+ Assert.assertNotNull(vhostUserIface);
+ Assert.assertEquals(VhostUserRole.Client, vhostUserIface.getRole());
+ Assert.assertEquals(SOCKET, vhostUserIface.getSocket());
+ L2 l2Iface = vppIface.getL2();
+ if (l2Iface != null) {
+ Interconnection interconnection = l2Iface.getInterconnection();
+ if (interconnection != null) {
+ if (interconnection instanceof BridgeBased) {
+ BridgeBased bridgeL2Iface = (BridgeBased) interconnection;
+ Assert.assertTrue(Strings.isNullOrEmpty(bridgeL2Iface.getBridgeDomain()));
+ }
+ }
+ }
+ // assert state on ODL data store
+ ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
+ Optional<LocationProvider> optLocationProvider = rTx.read(LogicalDatastoreType.CONFIGURATION, IidFactory.locationProviderIid(VppEndpointLocationProvider.VPP_ENDPOINT_LOCATION_PROVIDER)).get();
+ Assert.assertTrue(optLocationProvider.isPresent());
+ List<ProviderAddressEndpointLocation> epLocs = optLocationProvider.get().getProviderAddressEndpointLocation();
+ Assert.assertNotNull(epLocs);
+ Assert.assertEquals(1, epLocs.size());
+ ProviderAddressEndpointLocation epLoc = VppEndpointLocationProvider.createProviderAddressEndpointLocation(vhostEp);
+ Assert.assertEquals(epLoc, epLocs.get(0));
+ }
+
+ @Test
+ public void testVppEndpointChanged_deleted() throws Exception {
+ VppEndpoint vhostEp = vhostVppEpBuilder().build();
+ VppEndpointConfEvent createVppEpEvent = new VppEndpointConfEvent(BASIC_VPP_EP_IID, null, vhostEp);
+ VppEndpointConfEvent deleteVppEpEvent = new VppEndpointConfEvent(BASIC_VPP_EP_IID, vhostEp, null);
+
+ manager.vppEndpointChanged(createVppEpEvent);
+ manager.vppEndpointChanged(deleteVppEpEvent);
+ // assert state on data store behind mount point
+ ReadOnlyTransaction rTxMount = mountPointDataBroker.newReadOnlyTransaction();
+ Optional<Interface> potentialIface =
+ rTxMount.read(LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.builder(Interfaces.class)
+ .child(Interface.class, new InterfaceKey(vhostEp.getVppInterfaceName()))
+ .build()).get();
+ Assert.assertFalse(potentialIface.isPresent());
+ // assert state on ODL data store
+ ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
+ ProviderAddressEndpointLocation providerAddressEndpointLocation =
+ VppEndpointLocationProvider.createProviderAddressEndpointLocation(vhostEp);
+ InstanceIdentifier<ProviderAddressEndpointLocation> providerAddressEndpointLocationIid = IidFactory
+ .providerAddressEndpointLocationIid(VppEndpointLocationProvider.VPP_ENDPOINT_LOCATION_PROVIDER,
+ providerAddressEndpointLocation.getKey());
+ Optional<ProviderAddressEndpointLocation> optProvEpLoc =
+ rTx.read(LogicalDatastoreType.CONFIGURATION, providerAddressEndpointLocationIid).get();
+ Assert.assertFalse(optProvEpLoc.isPresent());
+ }
+
+ private VppEndpointBuilder vhostVppEpBuilder() {
+ return basicVppEpBuilder().setVppInterfaceName(IFACE_NAME)
+ .setVppNodePath(NODE_IID)
+ .setInterfaceTypeChoice(new VhostUserCaseBuilder().setSocket(SOCKET).build());
+ }
+
+ private VppEndpointBuilder basicVppEpBuilder() {
+ return new VppEndpointBuilder().setAddress(ADDRESS)
+ .setAddressType(AddressType.class)
+ .setContextId(CONTEXT_ID)
+ .setContextType(ContextType.class);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 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.groupbasedpolicy.renderer.vpp.listener;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.event.VppEndpointConfEvent;
+import org.opendaylight.groupbasedpolicy.test.CustomDataBrokerTest;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContextId;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint_location_provider.rev160419.LocationProviders;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.AddressType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.ContextType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.Forwarding;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.Config;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpointBuilder;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import com.google.common.base.Optional;
+import com.google.common.eventbus.EventBus;
+
+public class VppEndpointListenerTest extends CustomDataBrokerTest {
+
+ private final static String ADDRESS = "1.1.1.1/32";
+ private final static ContextId CONTEXT_ID = new ContextId("ctx1");
+ private final static String IFACE_NAME = "ifaceName";
+
+ private DataBroker dataBroker;
+ private VppEndpointListener listener;
+ private EventBus eventBusMock;
+
+ @Override
+ public Collection<Class<?>> getClassesFromModules() {
+ return Arrays.asList(Node.class, VppEndpoint.class, Forwarding.class, LocationProviders.class);
+ }
+
+ @Before
+ public void init() {
+ dataBroker = getDataBroker();
+ eventBusMock = Mockito.mock(EventBus.class);
+ listener = new VppEndpointListener(dataBroker, eventBusMock);
+ }
+
+ @Test
+ public void testOnWrite() throws Exception {
+ ArgumentCaptor<VppEndpointConfEvent> argVppEpEvent = ArgumentCaptor.forClass(VppEndpointConfEvent.class);
+ VppEndpoint vppEndpoint = new VppEndpointBuilder().setAddress(ADDRESS)
+ .setAddressType(AddressType.class)
+ .setContextId(CONTEXT_ID)
+ .setContextType(ContextType.class)
+ .build();
+ InstanceIdentifier<VppEndpoint> vppEpIid =
+ InstanceIdentifier.builder(Config.class).child(VppEndpoint.class, vppEndpoint.getKey()).build();
+ WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
+ wTx.put(LogicalDatastoreType.CONFIGURATION, vppEpIid, vppEndpoint);
+ wTx.submit().get();
+
+ Mockito.verify(eventBusMock).post(argVppEpEvent.capture());
+ VppEndpointConfEvent capturedVppEpEvent = argVppEpEvent.getValue();
+ Assert.assertEquals(vppEpIid, capturedVppEpEvent.getIid());
+ assertEqualsOptional(null, capturedVppEpEvent.getBefore());
+ assertEqualsOptional(vppEndpoint, capturedVppEpEvent.getAfter());
+ }
+
+ @Test
+ public void testOnDelete() throws Exception {
+ ArgumentCaptor<VppEndpointConfEvent> argVppEpEvent = ArgumentCaptor.forClass(VppEndpointConfEvent.class);
+ VppEndpoint vppEndpoint = new VppEndpointBuilder().setAddress(ADDRESS)
+ .setAddressType(AddressType.class)
+ .setContextId(CONTEXT_ID)
+ .setContextType(ContextType.class)
+ .build();
+ InstanceIdentifier<VppEndpoint> vppEpIid =
+ InstanceIdentifier.builder(Config.class).child(VppEndpoint.class, vppEndpoint.getKey()).build();
+ WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
+ wTx.put(LogicalDatastoreType.CONFIGURATION, vppEpIid, vppEndpoint);
+ wTx.submit().get();
+ wTx = getDataBroker().newWriteOnlyTransaction();
+ wTx.delete(LogicalDatastoreType.CONFIGURATION, vppEpIid);
+ wTx.submit().get();
+
+ Mockito.verify(eventBusMock, Mockito.times(2)).post(argVppEpEvent.capture());
+ VppEndpointConfEvent capturedVppEpEvent = argVppEpEvent.getAllValues().get(1);
+ Assert.assertEquals(vppEpIid, capturedVppEpEvent.getIid());
+ assertEqualsOptional(vppEndpoint, capturedVppEpEvent.getBefore());
+ assertEqualsOptional(null, capturedVppEpEvent.getAfter());
+ }
+
+ @Test
+ public void testOnSubtreeModified() throws Exception {
+ ArgumentCaptor<VppEndpointConfEvent> argVppEpEvent = ArgumentCaptor.forClass(VppEndpointConfEvent.class);
+ VppEndpointBuilder vppEndpointBuilder = new VppEndpointBuilder().setAddress(ADDRESS)
+ .setAddressType(AddressType.class)
+ .setContextId(CONTEXT_ID)
+ .setContextType(ContextType.class);
+ VppEndpoint vppEndpoint = vppEndpointBuilder.build();
+ InstanceIdentifier<VppEndpoint> vppEpIid =
+ InstanceIdentifier.builder(Config.class).child(VppEndpoint.class, vppEndpoint.getKey()).build();
+ WriteTransaction wTx = getDataBroker().newWriteOnlyTransaction();
+ wTx.put(LogicalDatastoreType.CONFIGURATION, vppEpIid, vppEndpoint);
+ wTx.submit().get();
+ VppEndpoint modifiedVppEndpoint = vppEndpointBuilder.setVppInterfaceName(IFACE_NAME).build();
+ wTx = getDataBroker().newWriteOnlyTransaction();
+ wTx.put(LogicalDatastoreType.CONFIGURATION, vppEpIid, modifiedVppEndpoint);
+ wTx.submit().get();
+
+ Mockito.verify(eventBusMock, Mockito.times(2)).post(argVppEpEvent.capture());
+ VppEndpointConfEvent capturedFirstVppEpEvent = argVppEpEvent.getAllValues().get(0);
+ Assert.assertEquals(vppEpIid, capturedFirstVppEpEvent.getIid());
+ assertEqualsOptional(null, capturedFirstVppEpEvent.getBefore());
+ assertEqualsOptional(vppEndpoint, capturedFirstVppEpEvent.getAfter());
+ VppEndpointConfEvent capturedSecondVppEpEvent = argVppEpEvent.getAllValues().get(1);
+ Assert.assertEquals(vppEpIid, capturedSecondVppEpEvent.getIid());
+ assertEqualsOptional(vppEndpoint, capturedSecondVppEpEvent.getBefore());
+ assertEqualsOptional(modifiedVppEndpoint, capturedSecondVppEpEvent.getAfter());
+ }
+
+ private <T> void assertEqualsOptional(T expected, Optional<T> actual) {
+ if (expected == null) {
+ Assert.assertFalse(actual.isPresent());
+ } else {
+ Assert.assertTrue(actual.isPresent());
+ Assert.assertEquals(expected, actual.get());
+ }
+ }
+
+}
--- /dev/null
+
+package org.opendaylight.groupbasedpolicy.renderer.vpp.manager;
+
+import com.google.common.base.Optional;
+import com.google.common.eventbus.EventBus;
+import com.google.common.util.concurrent.CheckedFuture;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Matchers;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.opendaylight.controller.md.sal.binding.api.*;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.controller.sal.binding.api.BindingAwareBroker;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.VppRendererDataBrokerTest;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.listener.VppNodeListener;
+import org.opendaylight.groupbasedpolicy.renderer.vpp.util.VppIidFactory;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Host;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
+import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.PortNumber;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.Renderer;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.RendererKey;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNode;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.connection.status.AvailableCapabilitiesBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.netconf.node.connection.status.UnavailableCapabilitiesBuilder;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.NodeId;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.Node;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeBuilder;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.NodeKey;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Test for {@link VppNodeManager} and {@link VppNodeListener}.
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class VppManagerDataStoreTest extends VppRendererDataBrokerTest {
+
+ private static final String V3PO_CAPABILITY = "(urn:opendaylight:params:xml:ns:yang:v3po?revision=2015-01-05)v3po";
+ private static final String INTERFACES_CAPABILITY =
+ "(urn:ietf:params:xml:ns:yang:ietf-interfaces?revision=2014-05-08)ietf-interfaces";
+ private static final String NODE_NAME = "testVpp";
+
+ private final InstanceIdentifier<Node> nodeIid = VppIidFactory.getNodeIid(new NodeKey(new NodeId(NODE_NAME)));
+
+ @Mock
+ BindingAwareBroker.ProviderContext providerContext;
+ @Mock
+ MountPointService mountPointService;
+ @Mock
+ MountPoint mountPoint;
+ @Mock
+ DataBroker dataBroker2;
+
+ private DataBroker dataBroker;
+ private VppNodeListener vppNodeListener;
+ private VppNodeManager vppNodeManager;
+
+ @Before
+ public void setUp() throws Exception {
+ Mockito.when(providerContext.getSALService(Matchers.<Class<MountPointService>>any()))
+ .thenReturn(mountPointService);
+ Mockito.when(mountPointService.getMountPoint(Matchers.<InstanceIdentifier<Node>>any()))
+ .thenReturn(Optional.of(mountPoint));
+ Mockito.when(mountPoint.getService(Matchers.<Class<DataBroker>>any())).thenReturn(Optional.of(dataBroker2));
+ dataBroker = getDataBroker();
+ vppNodeManager = new VppNodeManager(dataBroker, providerContext);
+ vppNodeListener = new VppNodeListener(dataBroker, vppNodeManager, new EventBus());
+ }
+
+ private Node createNode(final String name, NetconfNodeConnectionStatus.ConnectionStatus status) {
+ Host host = new Host(new IpAddress(new Ipv4Address("192.168.255.101")));
+ PortNumber portNumber = new PortNumber(2830);
+
+ List<String> avaibleCapabilitiesList = new ArrayList<>();
+ avaibleCapabilitiesList.add(V3PO_CAPABILITY);
+ avaibleCapabilitiesList.add(INTERFACES_CAPABILITY);
+
+ NetconfNode netconfNode = new NetconfNodeBuilder().setHost(host)
+ .setPort(portNumber)
+ .setUnavailableCapabilities(new UnavailableCapabilitiesBuilder().build())
+ .setAvailableCapabilities(
+ new AvailableCapabilitiesBuilder().setAvailableCapability(avaibleCapabilitiesList).build())
+ .setConnectionStatus(status)
+ .build();
+
+ return new NodeBuilder().setNodeId(new NodeId(name)).addAugmentation(NetconfNode.class, netconfNode).build();
+ }
+
+ @Test
+ public void connectNode() throws ReadFailedException {
+ WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
+ Node testVppNode = createNode(NODE_NAME, NetconfNodeConnectionStatus.ConnectionStatus.Connected);
+
+ writeTransaction.put(LogicalDatastoreType.OPERATIONAL, nodeIid, testVppNode, true);
+
+ writeTransaction.submit();
+
+ ReadOnlyTransaction readOnlyTransaction = dataBroker.newReadOnlyTransaction();
+ CheckedFuture<Optional<Renderer>, ReadFailedException> future =
+ readOnlyTransaction.read(LogicalDatastoreType.OPERATIONAL,
+ VppIidFactory.getRendererIID(new RendererKey(VppNodeManager.vppRenderer)));
+ Optional<Renderer> rendererOptional = future.checkedGet();
+
+ Assert.assertTrue(rendererOptional.isPresent());
+ Assert.assertEquals(1, rendererOptional.get().getRendererNodes().getRendererNode().size());
+ Assert.assertEquals(nodeIid, rendererOptional.get().getRendererNodes().getRendererNode().get(0).getNodePath());
+ }
+
+ @Test
+ public void disconnectNode() throws ReadFailedException, InterruptedException {
+ WriteTransaction writeTransaction = dataBroker.newWriteOnlyTransaction();
+ Node testVppNode = createNode(NODE_NAME, NetconfNodeConnectionStatus.ConnectionStatus.Connected);
+
+ writeTransaction.put(LogicalDatastoreType.OPERATIONAL, nodeIid, testVppNode, true);
+
+ writeTransaction.submit();
+
+ ReadOnlyTransaction readOnlyTransaction = dataBroker.newReadOnlyTransaction();
+ CheckedFuture<Optional<Renderer>, ReadFailedException> future =
+ readOnlyTransaction.read(LogicalDatastoreType.OPERATIONAL,
+ VppIidFactory.getRendererIID(new RendererKey(VppNodeManager.vppRenderer)));
+ Optional<Renderer> rendererOptional = future.checkedGet();
+
+ Assert.assertTrue(rendererOptional.isPresent());
+ Assert.assertEquals(1, rendererOptional.get().getRendererNodes().getRendererNode().size());
+ Assert.assertEquals(nodeIid, rendererOptional.get().getRendererNodes().getRendererNode().get(0).getNodePath());
+
+ WriteTransaction writeTransaction2 = dataBroker.newWriteOnlyTransaction();
+ Node testVppNode2 = createNode(NODE_NAME, NetconfNodeConnectionStatus.ConnectionStatus.Connecting);
+
+ writeTransaction2.put(LogicalDatastoreType.OPERATIONAL, nodeIid, testVppNode2, true);
+
+ writeTransaction2.submit();
+
+ ReadOnlyTransaction readOnlyTransaction2 = dataBroker.newReadOnlyTransaction();
+ CheckedFuture<Optional<Renderer>, ReadFailedException> future2 =
+ readOnlyTransaction2.read(LogicalDatastoreType.OPERATIONAL,
+ VppIidFactory.getRendererIID(new RendererKey(VppNodeManager.vppRenderer)));
+ Optional<Renderer> rendererOptional2 = future2.checkedGet();
+
+ Assert.assertTrue(rendererOptional2.isPresent());
+ Assert.assertEquals(0, rendererOptional2.get().getRendererNodes().getRendererNode().size());
+ }
+
+ @After
+ public void cleanUp() throws Exception {
+ vppNodeListener.close();
+ }
+}
--- /dev/null
+package org.opendaylight.groupbasedpolicy.renderer.vpp.util;
+
+import com.google.common.util.concurrent.Futures;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InOrder;
+import org.mockito.Matchers;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;
+import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.Renderer;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.RendererNodes;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.nodes.RendererNode;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.renderers.renderer.renderer.nodes.RendererNodeBuilder;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+
+/**
+ * Test for {@link VppNodeWriter}.
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class VppNodeWriterTest {
+
+ private static final String RENDERER_NAME = "vpp-renderer";
+
+ @Mock
+ private DataBroker dataBroker;
+ @Mock
+ private WriteTransaction wTx;
+ @Captor
+ private ArgumentCaptor<InstanceIdentifier<RendererNodes>> rendererNodesPathCpt;
+ @Captor
+ private ArgumentCaptor<RendererNodes> rendererNodesCpt;
+
+ private InOrder inOrder;
+
+ private VppNodeWriter nodeWriter;
+
+ @Before
+ public void setUp() throws Exception {
+ nodeWriter = new VppNodeWriter();
+ Mockito.when(dataBroker.newWriteOnlyTransaction()).thenReturn(wTx);
+ Mockito.when(wTx.submit()).thenReturn(Futures.immediateCheckedFuture(null));
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ inOrder.verifyNoMoreInteractions();
+ }
+
+ @Test
+ public void testCommitToDatastore_with_node() throws Exception {
+ final RendererNode node = new RendererNodeBuilder().build();
+ nodeWriter.cache(node);
+ nodeWriter.commitToDatastore(dataBroker);
+
+ commonChecks();
+
+ final RendererNodes rendererNodes = rendererNodesCpt.getValue();
+ Assert.assertEquals(1, rendererNodes.getRendererNode().size());
+ }
+
+ @Test
+ public void testCommitToDatastore_empty() throws Exception {
+ nodeWriter.commitToDatastore(dataBroker);
+
+ commonChecks();
+
+ final RendererNodes rendererNodes = rendererNodesCpt.getValue();
+ Assert.assertEquals(0, rendererNodes.getRendererNode().size());
+ }
+
+ private void commonChecks() {
+ inOrder = Mockito.inOrder(dataBroker, wTx);
+ inOrder.verify(dataBroker).newWriteOnlyTransaction();
+ inOrder.verify(wTx).merge(Matchers.eq(LogicalDatastoreType.OPERATIONAL), rendererNodesPathCpt.capture(),
+ rendererNodesCpt.capture(), Matchers.eq(true));
+ inOrder.verify(wTx).submit();
+
+ final InstanceIdentifier<RendererNodes> rendererNodesPath = rendererNodesPathCpt.getValue();
+ Assert.assertEquals(RENDERER_NAME, extractRendererName(rendererNodesPath));
+ }
+
+ private String extractRendererName(final InstanceIdentifier<RendererNodes> rendererNodesPath) {
+ return rendererNodesPath.firstKeyOf(Renderer.class).getName().getValue();
+ }
+}
</dependency>
<dependency>
<groupId>org.opendaylight.groupbasedpolicy</groupId>
- <artifactId>groupbasedpolicy</artifactId>
+ <artifactId>l2-l3-domain-extension</artifactId>
</dependency>
<!-- sxp deps -->