--- /dev/null
+/*
+ * Copyright (c) 2015 Inocybe 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.ovsdb.openstack.netvirt;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyString;
+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 java.net.HttpURLConnection;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.opendaylight.neutron.spi.INeutronLoadBalancerCRUD;
+import org.opendaylight.neutron.spi.INeutronLoadBalancerPoolCRUD;
+import org.opendaylight.neutron.spi.INeutronNetworkCRUD;
+import org.opendaylight.neutron.spi.INeutronPortCRUD;
+import org.opendaylight.neutron.spi.INeutronSubnetCRUD;
+import org.opendaylight.neutron.spi.NeutronLoadBalancer;
+import org.opendaylight.neutron.spi.NeutronLoadBalancerPool;
+import org.opendaylight.neutron.spi.NeutronLoadBalancerPoolMember;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
+import org.opendaylight.ovsdb.openstack.netvirt.api.LoadBalancerConfiguration;
+import org.opendaylight.ovsdb.openstack.netvirt.api.LoadBalancerConfiguration.LoadBalancerPoolMember;
+import org.opendaylight.ovsdb.openstack.netvirt.api.LoadBalancerProvider;
+import org.opendaylight.ovsdb.openstack.netvirt.api.NodeCacheManager;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+/**
+ * Unit test for {@link LBaaSPoolMemberHandler}
+ */
+@PrepareForTest(NeutronCacheUtils.class)
+@RunWith(PowerMockRunner.class)
+public class LBaaSPoolHandlerTest {
+
+ @InjectMocks LBaaSPoolHandler lBaaSPoolHandler;
+
+ @Mock private INeutronLoadBalancerPoolCRUD neutronLBPoolCache;
+ @Mock private INeutronLoadBalancerCRUD neutronLBCache;
+ @Mock private LoadBalancerProvider loadBalancerProvider;
+ @Mock private NodeCacheManager nodeCacheManager;
+
+ @Mock private NeutronLoadBalancerPool neutronLBPool;
+
+ @Before
+ public void setUp() {
+ when(neutronLBPool.getLoadBalancerPoolProtocol()).thenReturn(LoadBalancerConfiguration.PROTOCOL_HTTP);
+
+ List<NeutronLoadBalancerPoolMember> members = new ArrayList();
+ NeutronLoadBalancerPoolMember neutronLBPoolMember = mock(NeutronLoadBalancerPoolMember.class);
+ when(neutronLBPoolMember.getPoolMemberAdminStateIsUp()).thenReturn(true);
+ when(neutronLBPoolMember.getPoolMemberSubnetID()).thenReturn("subnetID");
+ when(neutronLBPoolMember.getPoolMemberID()).thenReturn("pool_memberID");
+ when(neutronLBPoolMember.getPoolMemberAddress()).thenReturn("pool_member_address");
+ when(neutronLBPoolMember.getPoolMemberProtoPort()).thenReturn(1);
+ members.add(neutronLBPoolMember);
+ when(neutronLBPool.getLoadBalancerPoolMembers()).thenReturn(members);
+
+ List<NeutronLoadBalancer> list_neutronLB = new ArrayList();
+ NeutronLoadBalancer neutronLB = mock(NeutronLoadBalancer.class);
+ when(neutronLB.getLoadBalancerName()).thenReturn("load_balancer_name");
+ when(neutronLB.getLoadBalancerVipAddress()).thenReturn("vip_address");
+ when(neutronLB.getLoadBalancerVipSubnetID()).thenReturn("subnetID");
+ list_neutronLB.add(neutronLB);
+ when(neutronLBCache.getAllNeutronLoadBalancers()).thenReturn(list_neutronLB);
+
+ Map.Entry<String,String> providerInfo = mock(Entry.class);
+ when(providerInfo.getKey()).thenReturn("key");
+ when(providerInfo.getValue()).thenReturn("value");
+
+ PowerMockito.mockStatic(NeutronCacheUtils.class);
+ when(NeutronCacheUtils.getMacAddress(any(INeutronPortCRUD.class), anyString(), anyString())).thenReturn("mac_address");
+ when(NeutronCacheUtils.getProviderInformation(any(INeutronNetworkCRUD.class), any(INeutronSubnetCRUD.class), anyString())).thenReturn(providerInfo);
+ }
+
+ /**
+ * Test method {@link LBaaSPoolHandler#canCreateNeutronLoadBalancerPool(NeutronLoadBalancerPool)}
+ */
+ @Test
+ public void testCanCreateNeutronLoadBalancerPoolMember() {
+ when(neutronLBPool.getLoadBalancerPoolProtocol())
+ .thenReturn(LoadBalancerConfiguration.PROTOCOL_HTTP) // to test HTTP_OK
+ .thenReturn(null) // to test HTTP_BAD_REQUEST
+ .thenReturn("dummy_proto"); // to test HTTP_NOT_ACCEPTABLE
+
+ assertEquals("Error, canCreateNeutronLoadBalancerPool() didn't return the correct HTTP flag", HttpURLConnection.HTTP_OK, lBaaSPoolHandler.canCreateNeutronLoadBalancerPool(neutronLBPool));
+ assertEquals("Error, canCreateNeutronLoadBalancerPool() didn't return the correct HTTP flag", HttpURLConnection.HTTP_BAD_REQUEST, lBaaSPoolHandler.canCreateNeutronLoadBalancerPool(neutronLBPool));
+ assertEquals("Error, canCreateNeutronLoadBalancerPool() didn't return the correct HTTP flag", HttpURLConnection.HTTP_NOT_ACCEPTABLE, lBaaSPoolHandler.canCreateNeutronLoadBalancerPool(neutronLBPool));
+ }
+
+ /**
+ * Test method {@link LBaaSPoolHandler#canUpdateNeutronLoadBalancerPool(NeutronLoadBalancerPool, NeutronLoadBalancerPool)}
+ */
+ public void testCanUpdateNeutronLoadBalancerPool() {
+ assertEquals("Error, did not return the correct HTTP flag", HttpURLConnection.HTTP_NOT_IMPLEMENTED, lBaaSPoolHandler.canUpdateNeutronLoadBalancerPool(any(NeutronLoadBalancerPool.class), any(NeutronLoadBalancerPool.class)));
+ }
+
+ /**
+ * Test method {@link LBaaSPoolHandler#canDeleteNeutronLoadBalancerPool(NeutronLoadBalancerPool)}
+ */
+ @Test
+ public void testCanDeleteNeutronLoadBalancerPool() {
+ when(neutronLBPool.getLoadBalancerPoolProtocol())
+ .thenReturn(LoadBalancerConfiguration.PROTOCOL_HTTP) // to test HTTP_OK
+ .thenReturn(null) // to test HTTP_BAD_REQUEST
+ .thenReturn("dummy_proto"); // to test HTTP_NOT_ACCEPTABLE
+
+ assertEquals("Error, canDeleteNeutronLoadBalancerPool() didn't return the correct HTTP flag", HttpURLConnection.HTTP_OK, lBaaSPoolHandler.canDeleteNeutronLoadBalancerPool(neutronLBPool));
+ assertEquals("Error, canDeleteNeutronLoadBalancerPool() didn't return the correct HTTP flag", HttpURLConnection.HTTP_BAD_REQUEST, lBaaSPoolHandler.canDeleteNeutronLoadBalancerPool(neutronLBPool));
+ assertEquals("Error, canDeleteNeutronLoadBalancerPool() didn't return the correct HTTP flag", HttpURLConnection.HTTP_NOT_ACCEPTABLE, lBaaSPoolHandler.canDeleteNeutronLoadBalancerPool(neutronLBPool));
+ }
+
+ /**
+ * Test method {@link LBaaSPoolHandler#processEvent(AbstractEvent)}
+ */
+ @Test
+ public void testProcessEvent() {
+ LBaaSPoolHandler lbaasPoolHandlerSpy = Mockito.spy(lBaaSPoolHandler);
+
+ NorthboundEvent ev = mock(NorthboundEvent.class);
+ when(ev.getLoadBalancerPool()).thenReturn(neutronLBPool);
+
+ List<Node> list_node = new ArrayList();
+ list_node .add(mock(Node.class));
+ when(nodeCacheManager.getNodes()).thenReturn(list_node);
+
+ when(ev.getAction()).thenReturn(Action.ADD);
+ lbaasPoolHandlerSpy.processEvent(ev);
+ verify(lbaasPoolHandlerSpy, times(1)).extractLBConfiguration(any(NeutronLoadBalancerPool.class));
+
+ when(ev.getAction()).thenReturn(Action.DELETE);
+ lbaasPoolHandlerSpy.processEvent(ev);
+ verify(lbaasPoolHandlerSpy, times(2)).extractLBConfiguration(any(NeutronLoadBalancerPool.class)); // 1 + 1 above
+
+ when(ev.getAction()).thenReturn(Action.UPDATE);
+ lbaasPoolHandlerSpy.processEvent(ev);
+ verify(lbaasPoolHandlerSpy, times(2)).extractLBConfiguration(any(NeutronLoadBalancerPool.class)); // same as before as nothing as been done
+ }
+
+ /**
+ * Test method {@link LBaaSPoolHandler#extractLBConfiguration(NeutronLoadBalancerPool)}
+ */
+ @Test
+ public void testExtractLBConfiguration() {
+ List<LoadBalancerConfiguration> list_lbConfig = lBaaSPoolHandler.extractLBConfiguration(neutronLBPool);
+ LoadBalancerConfiguration lbConfig = list_lbConfig.get(0);
+
+ verify(neutronLBCache, times(1)).getAllNeutronLoadBalancers();
+
+ // make sure the load balancer configuration was correctly populated
+ assertEquals("Error, did not return the correct value", "key", lbConfig.getProviderNetworkType());
+ assertEquals("Error, did not return the correct value", "value", lbConfig.getProviderSegmentationId());
+ assertEquals("Error, did not return the correct value", "mac_address", lbConfig.getVmac());
+
+ // make sure the load balancer pool member was correctly populated
+ LoadBalancerPoolMember member = lbConfig.getMembers().get("pool_memberID");
+ assertEquals("Error, did not return the correct value", "pool_member_address", member.getIP());
+ assertEquals("Error, did not return the correct value", "mac_address", member.getMAC());
+ assertEquals("Error, did not return the correct value", LoadBalancerConfiguration.PROTOCOL_HTTP, member.getProtocol());
+ assertTrue("Error, did not return the correct value", 1 == member.getPort());
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 Inocybe 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.ovsdb.openstack.netvirt;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Matchers.same;
+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 java.net.HttpURLConnection;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.opendaylight.neutron.spi.INeutronNetworkCRUD;
+import org.opendaylight.neutron.spi.NeutronNetwork;
+import org.opendaylight.ovsdb.lib.notation.Column;
+import org.opendaylight.ovsdb.lib.notation.Row;
+import org.opendaylight.ovsdb.lib.notation.UUID;
+import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
+import org.opendaylight.ovsdb.openstack.netvirt.api.BridgeConfigurationManager;
+import org.opendaylight.ovsdb.openstack.netvirt.api.TenantNetworkManager;
+import org.opendaylight.ovsdb.openstack.netvirt.impl.NeutronL3Adapter;
+import org.opendaylight.ovsdb.plugin.api.OvsdbConfigurationService;
+import org.opendaylight.ovsdb.plugin.api.OvsdbConnectionService;
+import org.opendaylight.ovsdb.schema.openvswitch.Interface;
+import org.opendaylight.ovsdb.schema.openvswitch.Port;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
+
+/**
+ * Unit test for {@link NetworkHandler}
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class NetworkHandlerTest {
+
+ @InjectMocks NetworkHandler networkHandler;
+
+ @Mock NeutronNetwork neutronNetwork;
+
+ @Mock private NeutronL3Adapter neutronL3Adapter;
+ @Mock private TenantNetworkManager tenantNetworkManager;
+ @Mock private INeutronNetworkCRUD neutronNetworkCache;
+ @Mock private OvsdbConnectionService connectionService;
+ @Mock private BridgeConfigurationManager bridgeConfigurationManager;
+ @Mock private OvsdbConfigurationService ovsdbConfigurationService;
+
+ /**
+ * Test method {@link NetworkHandler#canCreateNetwork(NeutronNetwork)}
+ */
+ @Test
+ public void testCanCreateNetwork() {
+ when(neutronNetwork.isShared())
+ .thenReturn(true)
+ .thenReturn(false);
+ assertEquals("Error, did not return the correct HTTP flag", HttpURLConnection.HTTP_NOT_ACCEPTABLE, networkHandler.canCreateNetwork(neutronNetwork));
+ assertEquals("Error, did not return the correct HTTP flag", HttpURLConnection.HTTP_CREATED, networkHandler.canCreateNetwork(neutronNetwork));
+ }
+
+ /**
+ * Test method {@link NetworkHandler#canUpdateNetwork(NeutronNetwork, NeutronNetwork)}
+ */
+ @Test
+ public void testCanUpdateNetwork() {
+ assertEquals("Error, did not return the correct HTTP flag", HttpURLConnection.HTTP_OK, networkHandler.canUpdateNetwork(neutronNetwork, neutronNetwork));
+ }
+
+ /**
+ * Test method {@link NetworkHandler#canDeleteNetwork(NeutronNetwork)}
+ */
+ @Test
+ public void testCanDeleteNetwork() {
+ assertEquals("Error, did not return the correct HTTP flag", HttpURLConnection.HTTP_OK, networkHandler.canDeleteNetwork(neutronNetwork));
+ }
+
+ /**
+ * Test method {@link NetworkHandler#processEvent(AbstractEvent)}
+ */
+ @Test
+ public void testProcessEvent() {
+ NetworkHandler networkHandlerSpy = Mockito.spy(networkHandler);
+
+ NorthboundEvent ev = mock(NorthboundEvent.class);
+ when(ev.getNeutronNetwork()).thenReturn(neutronNetwork);
+
+ when(ev.getAction()).thenReturn(Action.ADD);
+ networkHandlerSpy.processEvent(ev);
+ verify(neutronL3Adapter, times(1)).handleNeutronNetworkEvent(any(NeutronNetwork.class), same(Action.ADD));
+
+ when(ev.getAction()).thenReturn(Action.UPDATE);
+ networkHandlerSpy.processEvent(ev);
+ verify(neutronL3Adapter, times(1)).handleNeutronNetworkEvent(any(NeutronNetwork.class), same(Action.UPDATE));
+
+ /* configuration needed to pass doNeutronNetworkDeleted() function*/
+ Node node = mock(Node.class);
+ List<Node> nodes = new ArrayList();
+ nodes.add(node);
+ when(connectionService.getNodes()).thenReturn(nodes);
+
+ ConcurrentMap<String, Row> ports = new ConcurrentHashMap<>();
+ Row row = mock(Row.class);
+ ports.put("key", row);
+ when(ovsdbConfigurationService.getRows(any(Node.class), anyString())).thenReturn(ports);
+
+ Port port = mock(Port.class);
+ Column<GenericTableSchema, Set<UUID>> portColumns = mock(Column.class);
+ Set<UUID> interfaceUUIDs = new HashSet<UUID>();
+ UUID uuid = mock(UUID.class);
+ interfaceUUIDs.add(uuid);
+ when(port.getInterfacesColumn()).thenReturn(portColumns);
+ when(portColumns.getData()).thenReturn(interfaceUUIDs);
+ when(ovsdbConfigurationService.getTypedRow(any(Node.class), same(Port.class), any(Row.class))).thenReturn(port);
+
+ Interface iface = mock(Interface.class);
+ Column<GenericTableSchema, String> ifaceColumns = mock(Column.class);
+ when(iface.getTypeColumn()).thenReturn(ifaceColumns);
+ when(ifaceColumns.getData()).thenReturn(NetworkHandler.NETWORK_TYPE_VXLAN);
+ when(ovsdbConfigurationService.getTypedRow(any(Node.class), same(Interface.class), any(Row.class))).thenReturn(iface);
+ /**/
+
+ when(ev.getAction()).thenReturn(Action.DELETE);
+ networkHandlerSpy.processEvent(ev);
+ verify(neutronL3Adapter, times(1)).handleNeutronNetworkEvent(any(NeutronNetwork.class), same(Action.DELETE));
+ verify(networkHandlerSpy, times(1)).canDeleteNetwork(any(NeutronNetwork.class));
+ verify(tenantNetworkManager, times(1)).networkDeleted(anyString());
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 Inocybe 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.ovsdb.openstack.netvirt;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
+
+/**
+ * Unit test for {@link NodeCacheManagerEvent}
+ */
+public class NodeCacheManagerEventTest {
+
+ private NodeCacheManagerEvent nodeCacheManagerEvent;
+
+ @Before
+ public void setUp() {
+ nodeCacheManagerEvent = new NodeCacheManagerEvent("nodeIdentifier", Action.ADD);
+ }
+
+ @Test
+ public void testToString() {
+ assertEquals("Error, toString() did not return the correct string", "NodeCacheManagerEvent [action=ADD, nodeIdentifier=nodeIdentifier]", nodeCacheManagerEvent.toString());
+ }
+
+ @Test
+ public void testHashCode() {
+ assertNotNull("Error, hashCode shouldn't be null", nodeCacheManagerEvent.hashCode());
+ }
+
+ @Test
+ public void testEquals() {
+ assertTrue("Error, the two object should be equal", nodeCacheManagerEvent.equals(nodeCacheManagerEvent));
+ assertFalse("Error, the two object should not be equal", nodeCacheManagerEvent.equals(new String("dummy")));
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 Inocybe 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.ovsdb.openstack.netvirt;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Matchers.same;
+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 java.net.HttpURLConnection;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.opendaylight.neutron.spi.NeutronPort;
+import org.opendaylight.ovsdb.lib.notation.Column;
+import org.opendaylight.ovsdb.lib.notation.Row;
+import org.opendaylight.ovsdb.lib.notation.UUID;
+import org.opendaylight.ovsdb.lib.schema.GenericTableSchema;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Constants;
+import org.opendaylight.ovsdb.openstack.netvirt.impl.NeutronL3Adapter;
+import org.opendaylight.ovsdb.plugin.api.OvsdbConfigurationService;
+import org.opendaylight.ovsdb.plugin.api.OvsdbConnectionService;
+import org.opendaylight.ovsdb.schema.openvswitch.Interface;
+import org.opendaylight.ovsdb.schema.openvswitch.Port;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
+
+/**
+ * Unit test fort {@link PortHandler}
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class PortHandlerTest {
+
+ @InjectMocks PortHandler portHandler;
+
+ @Mock private OvsdbConfigurationService ovsdbConfigurationService;
+ @Mock private OvsdbConnectionService connectionService;
+ @Mock private NeutronL3Adapter neutronL3Adapter;
+
+ @Test
+ public void testCanCreatePort() {
+ assertEquals("Error, did not return the correct HTTP flag", HttpURLConnection.HTTP_CREATED, portHandler.canCreatePort(mock(NeutronPort.class)));
+ }
+
+ @Test
+ public void testCanUpdatePort() {
+ assertEquals("Error, did not return the correct HTTP flag", HttpURLConnection.HTTP_OK, portHandler.canUpdatePort(mock(NeutronPort.class), mock(NeutronPort.class)));
+ assertEquals("Error, did not return the correct HTTP flag", HttpURLConnection.HTTP_BAD_REQUEST, portHandler.canUpdatePort(null, null));
+ }
+
+ @Test
+ public void testCanDeletePort() {
+ assertEquals("Error, did not return the correct HTTP flag", HttpURLConnection.HTTP_OK, portHandler.canDeletePort(mock(NeutronPort.class)));
+ }
+
+ @Test
+ public void testProcessEvent() {
+ PortHandler portHandlerSpy = Mockito.spy(portHandler);
+
+ NeutronPort neutronPort = mock(NeutronPort.class);
+ when(neutronPort.getTenantID()).thenReturn("tenantID");
+ when(neutronPort.getNetworkUUID()).thenReturn("networkUUID");
+ when(neutronPort.getID()).thenReturn("ID");
+ when(neutronPort.getPortUUID()).thenReturn("portUUID");
+
+ NorthboundEvent ev = mock(NorthboundEvent.class);
+ when(ev.getPort()).thenReturn(neutronPort);
+
+ when(ev.getAction()).thenReturn(Action.ADD);
+ portHandlerSpy.processEvent(ev);
+ verify(neutronL3Adapter, times(1)).handleNeutronPortEvent(neutronPort, Action.ADD);
+
+ when(ev.getAction()).thenReturn(Action.UPDATE);
+ portHandlerSpy.processEvent(ev);
+ verify(neutronL3Adapter, times(1)).handleNeutronPortEvent(neutronPort, Action.UPDATE);
+
+
+ Node node = mock(Node.class);
+ List<Node> nodes = new ArrayList();
+ nodes.add(node);
+ when(connectionService.getNodes()).thenReturn(nodes);
+
+ Row row = mock(Row.class);
+ ConcurrentMap<String, Row> portRows = new ConcurrentHashMap();
+ portRows.put("key", row);
+ when(ovsdbConfigurationService.getRows(any(Node.class), anyString())).thenReturn(portRows );
+
+ Port port = mock(Port.class);
+ Column<GenericTableSchema, Set<UUID>> itfaceColumns = mock(Column.class);
+ when(port.getInterfacesColumn()).thenReturn(itfaceColumns);
+ Set<UUID> ifaceUUIDs = new HashSet();
+ ifaceUUIDs.add(mock(UUID.class));
+ when(itfaceColumns.getData()).thenReturn(ifaceUUIDs );
+ when(ovsdbConfigurationService.getTypedRow(any(Node.class), same(Port.class), any(Row.class))).thenReturn(port);
+
+ Interface itface = mock(Interface.class);
+ Column<GenericTableSchema, Map<String, String>> externalIdColumns = mock(Column.class);
+ Map<String, String> externalIds = new HashMap();
+ externalIds.put(Constants.EXTERNAL_ID_INTERFACE_ID, "portUUID");
+ when(externalIdColumns.getData()).thenReturn(externalIds);
+ when(itface.getExternalIdsColumn()).thenReturn(externalIdColumns);
+ when(ovsdbConfigurationService.getTypedRow(any(Node.class), same(Interface.class), any(Row.class))).thenReturn(itface);
+
+
+ when(ev.getAction()).thenReturn(Action.DELETE);
+ portHandlerSpy.processEvent(ev);
+ verify(neutronL3Adapter, times(1)).handleNeutronPortEvent(neutronPort, Action.DELETE);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 Inocybe 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.ovsdb.openstack.netvirt;
+
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import java.net.HttpURLConnection;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mockito;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.opendaylight.neutron.spi.NeutronSecurityGroup;
+import org.opendaylight.neutron.spi.NeutronSecurityRule;
+
+/**
+ * Unit test {@link PortSecurityHandler}
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class PortSecurityHandlerTest {
+
+ @InjectMocks private PortSecurityHandler portSecurityHandler;
+ private PortSecurityHandler posrtSecurityHandlerSpy;
+
+ @Before
+ public void setUp() {
+ posrtSecurityHandlerSpy = Mockito.spy(portSecurityHandler);
+ }
+
+ @Test
+ public void testCanCreateNeutronSecurityGroup() {
+ assertEquals("Error, did not return the correct HTTP flag", HttpURLConnection.HTTP_CREATED, portSecurityHandler.canCreateNeutronSecurityGroup(mock(NeutronSecurityGroup.class)));
+
+ posrtSecurityHandlerSpy.neutronSecurityGroupCreated(any(NeutronSecurityGroup.class));
+ verify(posrtSecurityHandlerSpy, times(1)).canCreateNeutronSecurityGroup(any(NeutronSecurityGroup.class));
+ }
+
+ @Test
+ public void testCanUpdateNeutronSecurityGroup() {
+ assertEquals("Error, did not return the correct HTTP flag", HttpURLConnection.HTTP_OK, portSecurityHandler.canUpdateNeutronSecurityGroup(mock(NeutronSecurityGroup.class), mock(NeutronSecurityGroup.class)));
+ }
+
+ @Test
+ public void testCanDeleteNeutronSecurityGroup() {
+ assertEquals("Error, did not return the correct HTTP flag", HttpURLConnection.HTTP_OK, portSecurityHandler.canDeleteNeutronSecurityGroup(mock(NeutronSecurityGroup.class)));
+
+ posrtSecurityHandlerSpy.neutronSecurityGroupDeleted(any(NeutronSecurityGroup.class));
+ verify(posrtSecurityHandlerSpy, times(1)).canDeleteNeutronSecurityGroup(any(NeutronSecurityGroup.class));
+ }
+
+ @Test
+ public void testCanCreateNeutronSecurityRule() {
+ assertEquals("Error, did not return the correct HTTP flag", HttpURLConnection.HTTP_CREATED, portSecurityHandler.canCreateNeutronSecurityRule(mock(NeutronSecurityRule.class)));
+
+ posrtSecurityHandlerSpy.neutronSecurityRuleCreated(any(NeutronSecurityRule.class));
+ verify(posrtSecurityHandlerSpy, times(1)).canCreateNeutronSecurityRule(any(NeutronSecurityRule.class));
+ }
+
+ @Test
+ public void testCanUpdateNeutronSecurityRule() {
+ assertEquals("Error, did not return the correct HTTP flag", HttpURLConnection.HTTP_OK, portSecurityHandler.canUpdateNeutronSecurityRule(mock(NeutronSecurityRule.class), mock(NeutronSecurityRule.class)));
+ }
+
+ @Test
+ public void testCanDeleteNeutronSecurityRule() {
+ assertEquals("Error, did not return the correct HTTP flag", HttpURLConnection.HTTP_OK, portSecurityHandler.canDeleteNeutronSecurityRule(mock(NeutronSecurityRule.class)));
+
+ posrtSecurityHandlerSpy.neutronSecurityRuleDeleted(any(NeutronSecurityRule.class));
+ verify(posrtSecurityHandlerSpy, times(1)).canDeleteNeutronSecurityRule(any(NeutronSecurityRule.class));
+ }
+
+ @Test
+ public void testProcessEvent() {
+ // TODO see PortSecurityHandler#processEvent()
+ }
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 Inocybe 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.ovsdb.openstack.netvirt;
+
+import static org.junit.Assert.assertEquals;
+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 java.net.HttpURLConnection;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.opendaylight.neutron.spi.NeutronRouter;
+import org.opendaylight.neutron.spi.NeutronRouter_Interface;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
+import org.opendaylight.ovsdb.openstack.netvirt.impl.NeutronL3Adapter;
+
+/**
+ * Unit test fort {@link RouterHandler}
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class RouterHandlerTest {
+
+ @InjectMocks RouterHandler routerHandler;
+
+ @Mock NeutronL3Adapter neutronL3Adapter;
+
+ @Test
+ public void testCanCreateRouter() {
+ assertEquals("Error, canCreateRouter() did not return the correct HTTP flag", HttpURLConnection.HTTP_OK, routerHandler.canCreateRouter(mock(NeutronRouter.class)));
+ }
+
+ @Test
+ public void testCanUpdateRouter() {
+ assertEquals("Error, canUpdateRouter() did not return the correct HTTP flag", HttpURLConnection.HTTP_OK, routerHandler.canUpdateRouter(mock(NeutronRouter.class), mock(NeutronRouter.class)));
+ }
+
+ @Test
+ public void testCanDeleteRouter() {
+ assertEquals("Error, canDeleteRouter() did not return the correct HTTP flag", HttpURLConnection.HTTP_OK, routerHandler.canDeleteRouter(mock(NeutronRouter.class)));
+ }
+
+ @Test
+ public void testCanAttachAndDettachInterface() {
+ NeutronRouter router = mock(NeutronRouter.class);
+ when(router.getName()).thenReturn("router_name");
+
+ NeutronRouter_Interface routerInterface = mock(NeutronRouter_Interface.class);
+ when(routerInterface.getPortUUID()).thenReturn("portUUID");
+ when(routerInterface.getSubnetUUID()).thenReturn("subnetUUID");
+
+ assertEquals("Error, canAttachInterface() did not return the correct HTTP flag", HttpURLConnection.HTTP_OK, routerHandler.canAttachInterface(router, routerInterface));
+ assertEquals("Error, canDetachInterface() did not return the correct HTTP flag", HttpURLConnection.HTTP_OK, routerHandler.canDetachInterface(router, routerInterface));
+ }
+
+ @Test
+ public void testProcessEvent() {
+ NorthboundEvent ev = mock(NorthboundEvent.class);
+
+ when(ev.getAction()).thenReturn(Action.UPDATE);
+ when(ev.getRouter()).thenReturn(mock(NeutronRouter.class));
+ when(ev.getRouterInterface())
+ .thenReturn(null)
+ .thenReturn(mock(NeutronRouter_Interface.class));
+
+ routerHandler.processEvent(ev);
+ verify(neutronL3Adapter, times(1)).handleNeutronRouterEvent(ev.getRouter(), Action.UPDATE);
+ routerHandler.processEvent(ev);
+ verify(neutronL3Adapter, times(1)).handleNeutronRouterInterfaceEvent(ev.getRouter(), ev.getRouterInterface(), Action.UPDATE);
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 Inocybe 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.ovsdb.openstack.netvirt;
+
+import static org.junit.Assert.assertEquals;
+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 java.net.HttpURLConnection;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.opendaylight.neutron.spi.NeutronSubnet;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
+import org.opendaylight.ovsdb.openstack.netvirt.impl.NeutronL3Adapter;
+
+/**
+ * Unit test fort {@link SubnetHandler}
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class SubnetHandlerTest {
+
+ @InjectMocks private SubnetHandler subnetHandler;
+
+ @Mock NeutronL3Adapter neutronl3Adapter;
+
+ @Test
+ public void testCanCreateSubnet() {
+ assertEquals("Error, canCreateSubnet() did not return the correct HTTP flag", HttpURLConnection.HTTP_CREATED, subnetHandler.canCreateSubnet(mock(NeutronSubnet.class)));
+ }
+
+ @Test
+ public void testCanUpdateSubnet() {
+ assertEquals("Error, canUpdateSubnet() did not return the correct HTTP flag", HttpURLConnection.HTTP_CREATED, subnetHandler.canUpdateSubnet(mock(NeutronSubnet.class), mock(NeutronSubnet.class)));
+ }
+
+ @Test
+ public void testCanDeleteSubnet() {
+ assertEquals("Error, canDeleteSubnet() did not return the correct HTTP flag", HttpURLConnection.HTTP_CREATED, subnetHandler.canDeleteSubnet(mock(NeutronSubnet.class)));
+ }
+
+ @Test
+ public void testProcessEvent() {
+ NorthboundEvent ev = mock(NorthboundEvent.class);
+ when(ev.getSubnet()).thenReturn(mock(NeutronSubnet.class));
+
+ when(ev.getAction()).thenReturn(Action.ADD);
+ subnetHandler.processEvent(ev);
+ verify(neutronl3Adapter, times(1)).handleNeutronSubnetEvent(ev.getSubnet(), ev.getAction());;
+
+ when(ev.getAction()).thenReturn(Action.DELETE);
+ subnetHandler.processEvent(ev);
+ verify(neutronl3Adapter, times(1)).handleNeutronSubnetEvent(ev.getSubnet(), ev.getAction());;
+
+ when(ev.getAction()).thenReturn(Action.UPDATE);
+ subnetHandler.processEvent(ev);
+ verify(neutronl3Adapter, times(1)).handleNeutronSubnetEvent(ev.getSubnet(), ev.getAction());;
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2015 Inocybe 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.ovsdb.openstack.netvirt.impl;
+import static org.junit.Assert.assertEquals;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.util.Map;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.InjectMocks;
+import org.mockito.Spy;
+import org.opendaylight.ovsdb.openstack.netvirt.NodeCacheManagerEvent;
+import org.opendaylight.ovsdb.openstack.netvirt.api.Action;
+import org.opendaylight.ovsdb.openstack.netvirt.api.NodeCacheListener;
+import org.opendaylight.ovsdb.utils.mdsal.node.NodeUtils;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
+import org.osgi.framework.ServiceReference;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+
+import com.google.common.collect.Maps;
+
+/**
+ * Unit test for {@link NodeCacheManagerImpl}
+ */
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(NodeUtils.class)
+public class NodeCacheManagerImplTest {
+
+ @InjectMocks NodeCacheManagerImpl nodeCacheManagerImpl;
+ @Spy private Map<Long, NodeCacheListener> handlers = Maps.newHashMap();
+
+ @Test
+ public void testProcessEvent() {
+ NodeCacheManagerEvent ev = mock(NodeCacheManagerEvent.class);
+ when(ev.getNodeIdentifier()).thenReturn("node_identifier");
+
+ PowerMockito.mockStatic(NodeUtils.class);
+ when(NodeUtils.getOpenFlowNode(anyString())).thenReturn(mock(Node.class));
+
+ when(ev.getAction()).thenReturn(Action.ADD);
+ nodeCacheManagerImpl.processEvent(ev);
+ assertEquals("Error, did not add the event", 1, nodeCacheManagerImpl.getNodes().size());
+
+ when(ev.getAction()).thenReturn(Action.DELETE);
+ nodeCacheManagerImpl.processEvent(ev);
+ assertEquals("Error, did not delete the event", 0, nodeCacheManagerImpl.getNodes().size());
+ }
+
+ @Test
+ public void testCacheListenerAddedAndRemoved() {
+ ServiceReference ref = mock(ServiceReference.class);
+ when(ref.getProperty(org.osgi.framework.Constants.SERVICE_ID)).thenReturn(Long.valueOf(1));
+
+ // add
+ nodeCacheManagerImpl.cacheListenerAdded(ref, mock(NodeCacheListener.class));
+ assertEquals("Error, cacheListenerAdded() did not add any listener", 1, handlers.size());
+ // remove
+ nodeCacheManagerImpl.cacheListenerRemoved(ref);
+ assertEquals("Error, cacheListenerAdded() did not remove any listener", 0, handlers.size());
+ }
+}
import network-topology {prefix "topo"; revision-date "2013-10-21"; }
import yang-ext { prefix "ext"; }
- import ietf-inet-types { prefix inet; }
+ import ietf-inet-types { prefix inet; revision-date 2010-09-24; }
revision "2015-01-05" {
description "Initial revision of overlay model";
import network-topology {prefix "topo"; revision-date "2013-10-21"; }
import yang-ext { prefix "ext"; }
- import ietf-inet-types { prefix inet; }
+ import ietf-inet-types { prefix inet; revision-date 2010-09-24; }
import overlay { prefix overlay; }
import ietf-yang-types { prefix yang; revision-date "2013-07-15";}
import opendaylight-l2-types { prefix ethertype; revision-date "2013-08-27";}
}
}
+ list openvswitch-other-configs {
+ description "Open_vSwitch table other configs";
+ key "other-config-key";
+ leaf other-config-key {
+ description "other-config name/key";
+ type string;
+ }
+ leaf other-config-value {
+ description "other-config value";
+ type string;
+ }
+ }
+
}
identity interface-type-base {
}
}
- grouping ovsdb-other-config-attributes {
- list other-configs {
- description "Other config attributes for OVSDB tables";
- key "other-config-key";
- leaf other-config-key {
- description "other-config name/key";
- type string;
- }
- leaf other-config-value {
- description "other-config value";
- type string;
- }
- }
- }
-
augment "/topo:network-topology/topo:topology/topo:node" {
description "Augmentation for bridge nodes managed by ovsdb";
ext:augment-identifier "ovsdb-bridge-augmentation";
description "Augment topology node for an ovsdb node";
ext:augment-identifier "ovsdb-node-augmentation";
uses ovsdb-node-attributes;
- uses ovsdb-other-config-attributes;
}
augment "/topo:network-topology/topo:topology/topo:node/topo:termination-point" {
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
import org.opendaylight.ovsdb.lib.OvsdbClient;
+import org.opendaylight.ovsdb.southbound.ovsdb.transact.BridgeOperationalState;
import org.opendaylight.ovsdb.southbound.ovsdb.transact.DataChangesManagedByOvsdbNodeEvent;
import org.opendaylight.ovsdb.southbound.ovsdb.transact.TransactCommandAggregator;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes) {
for (OvsdbConnectionInstance connectionInstance : connectionInstancesFromChanges(changes)) {
connectionInstance.transact(new TransactCommandAggregator(
- db,
+ new BridgeOperationalState(db, changes),
new DataChangesManagedByOvsdbNodeEvent(
SouthboundMapper.createInstanceIdentifier(connectionInstance.getKey()),
changes)));
.put(DatapathTypeNetdev.class,"netdev")
.build();
public static final String IID_EXTERNAL_ID_KEY = "opendaylight-iid";
+
+ public static enum VLANMODES {
+ ACCESS("access"),
+ NATIVE_TAGGED("native-tagged"),
+ NATIVE_UNTAGGED("native-untagged"),
+ TRUNK("trunk");
+
+ private final String mode;
+
+ private VLANMODES(String mode) {
+ this.mode = mode;
+ }
+ @Override
+ public String toString() {
+ return mode;
+ }
+
+ public String getMode() {
+ return this.mode;
+ }
+ }
}
.create(NetworkTopology.class)
.child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID))
.child(Node.class,createNodeKey(ip,port));
- LOG.info("Created ovsdb path: {}",path);
+ LOG.debug("Created ovsdb path: {}",path);
return path;
}
public class BridgeCreateCommand implements TransactCommand {
private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes;
+ private BridgeOperationalState operationalState;
private static final Logger LOG = LoggerFactory.getLogger(BridgeCreateCommand.class);
- public BridgeCreateCommand(AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes) {
+ public BridgeCreateCommand(BridgeOperationalState state, AsyncDataChangeEvent<InstanceIdentifier<?>,
+ DataObject> changes) {
+ this.operationalState = state;
this.changes = changes;
}
--- /dev/null
+package org.opendaylight.ovsdb.southbound.ovsdb.transact;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.concurrent.ExecutionException;
+
+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.AsyncDataChangeEvent;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
+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.node.TerminationPoint;
+import org.opendaylight.yang.gen.v1.urn.tbd.params.xml.ns.yang.network.topology.rev131021.network.topology.topology.node.TerminationPointKey;
+import org.opendaylight.yangtools.yang.binding.DataObject;
+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.util.concurrent.CheckedFuture;
+
+public class BridgeOperationalState {
+ private static final Logger LOG = LoggerFactory.getLogger(BridgeOperationalState.class);
+ private DataBroker db;
+ private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes;
+ private Map<InstanceIdentifier<Node>, Node> operationalNodes = new HashMap<InstanceIdentifier<Node>, Node>();
+
+ public BridgeOperationalState(DataBroker db, AsyncDataChangeEvent<InstanceIdentifier<?>,
+ DataObject> changes) {
+ this.db = db;
+ this.changes = changes;
+ ReadOnlyTransaction transaction = db.newReadOnlyTransaction();
+ Map<InstanceIdentifier<Node>, Node> nodeCreateOrUpdate =
+ TransactUtils.extractCreatedOrUpdatedOrRemoved(changes, Node.class);
+ if (nodeCreateOrUpdate != null) {
+ for (Entry<InstanceIdentifier<Node>, Node> entry: nodeCreateOrUpdate.entrySet()) {
+ CheckedFuture<Optional<Node>, ReadFailedException> nodeFuture =
+ transaction.read(LogicalDatastoreType.OPERATIONAL, entry.getKey());
+ try {
+ Optional<Node> nodeOptional = nodeFuture.get();
+ if (nodeOptional.isPresent()) {
+ operationalNodes.put(entry.getKey(), nodeOptional.get());
+ }
+ } catch (InterruptedException e) {
+ LOG.warn("Error reading from datastore",e);
+ } catch (ExecutionException e) {
+ LOG.warn("Error reading from datastore",e);
+ }
+ }
+ }
+ transaction.close();
+ }
+
+ public Optional<Node> getBridgeNode(InstanceIdentifier<?> iid) {
+ InstanceIdentifier<Node> nodeIid = iid.firstIdentifierOf(Node.class);
+ if (operationalNodes.containsKey(nodeIid)) {
+ return Optional.of(operationalNodes.get(nodeIid));
+ }
+ return Optional.absent();
+ }
+
+ public Optional<OvsdbBridgeAugmentation> getOvsdbBridgeAugmentation(InstanceIdentifier<?> iid) {
+ Optional<Node> nodeOptional = getBridgeNode(iid);
+ if (nodeOptional.isPresent() && nodeOptional.get().getAugmentation(OvsdbBridgeAugmentation.class) != null) {
+ return Optional.of(nodeOptional.get().getAugmentation(OvsdbBridgeAugmentation.class));
+ }
+ return Optional.absent();
+ }
+
+ public Optional<TerminationPoint> getBrideTermiationPoint(InstanceIdentifier<?> iid) {
+ Optional<Node> nodeOptional = getBridgeNode(iid);
+ if (nodeOptional.isPresent()) {
+ TerminationPointKey key = iid.firstKeyOf(TerminationPoint.class, TerminationPointKey.class);
+ if (key != null) {
+ for (TerminationPoint tp:nodeOptional.get().getTerminationPoint()) {
+ if (tp.getKey().equals(key)) {
+ return Optional.of(tp);
+ }
+ }
+ }
+ }
+ return Optional.absent();
+ }
+
+ public Optional<OvsdbTerminationPointAugmentation> getOvsdbTerminationPointAugmentation(InstanceIdentifier<?> iid) {
+ Optional<TerminationPoint> tpOptional = getBrideTermiationPoint(iid);
+ if (tpOptional.isPresent()
+ && tpOptional.get().getAugmentation(OvsdbTerminationPointAugmentation.class) != null) {
+ return Optional.of(tpOptional.get().getAugmentation(OvsdbTerminationPointAugmentation.class));
+ }
+ return Optional.absent();
+ }
+
+}
import java.util.Map;
import java.util.Set;
-import java.util.concurrent.ExecutionException;
-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.AsyncDataChangeEvent;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.ovsdb.lib.notation.Mutator;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import com.google.common.base.Optional;
import com.google.common.collect.Sets;
-import com.google.common.util.concurrent.CheckedFuture;
public class BridgeRemovedCommand implements TransactCommand {
private static final Logger LOG = LoggerFactory.getLogger(BridgeRemovedCommand.class);
private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes;
- private DataBroker db;
+ private BridgeOperationalState operationalState;
- public BridgeRemovedCommand(DataBroker db, AsyncDataChangeEvent<InstanceIdentifier<?>,
+ public BridgeRemovedCommand(BridgeOperationalState state, AsyncDataChangeEvent<InstanceIdentifier<?>,
DataObject> changes) {
- this.db = db;
+ this.operationalState = state;
this.changes = changes;
}
LOG.info("Received request to delete ovsdb node {}",ovsdbManagedNodeIid);
OvsdbBridgeAugmentation original = originals.get(ovsdbManagedNodeIid);
Bridge bridge = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Bridge.class,null);
- Optional<UUID> bridgeUuidOptional = getBridgeUUID(ovsdbManagedNodeIid);
- if (bridgeUuidOptional.isPresent()) {
- UUID bridgeUuid = bridgeUuidOptional.get();
+ Optional<OvsdbBridgeAugmentation> ovsdbAugmentationOptional = this.operationalState
+ .getOvsdbBridgeAugmentation(ovsdbManagedNodeIid);
+ if (ovsdbAugmentationOptional.isPresent() && ovsdbAugmentationOptional.get().getBridgeUuid() != null) {
+ UUID bridgeUuid = new UUID(ovsdbAugmentationOptional.get().getBridgeUuid().getValue());
OpenVSwitch ovs = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(),
OpenVSwitch.class,null);
transaction.add(op.delete(bridge.getSchema())
}
}
-
- private Optional<UUID> getBridgeUUID(InstanceIdentifier<OvsdbBridgeAugmentation> ovsdbManagedNodeIid) {
- Optional<UUID> result = Optional.absent();
- ReadOnlyTransaction transaction = db.newReadOnlyTransaction();
- CheckedFuture<Optional<OvsdbBridgeAugmentation>, ReadFailedException> future
- = transaction.read(LogicalDatastoreType.OPERATIONAL, ovsdbManagedNodeIid);
- Optional<OvsdbBridgeAugmentation> optional;
- try {
- optional = future.get();
- if (optional.isPresent()) {
- OvsdbBridgeAugmentation bridge = (OvsdbBridgeAugmentation) optional.get();
- if (bridge != null && bridge.getBridgeUuid() != null) {
- result = Optional.of(new UUID(bridge.getBridgeUuid().getValue()));
- }
- }
- } catch (InterruptedException e) {
- LOG.warn("Unable to retrieve bridge from operational store",e);
- } catch (ExecutionException e) {
- LOG.warn("Unable to retrieve bridge from operational store",e);
- }
- transaction.close();
- return result;
- }
-
}
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbNodeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchExternalIds;
import org.opendaylight.yangtools.yang.binding.DataObject;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigs;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
LOG.warn("Incomplete OVSDB Node external IDs");
}
}
+
+ List<OpenvswitchOtherConfigs> otherConfigs = ovsdbNode.getOpenvswitchOtherConfigs();
+ if (otherConfigs != null) {
+ HashMap<String, String> otherConfigsMap = new HashMap<String, String>();
+ for (OpenvswitchOtherConfigs otherConfig : otherConfigs) {
+ otherConfigsMap.put(otherConfig.getOtherConfigKey(), otherConfig.getOtherConfigValue());
+ }
+ try {
+ ovs.setOtherConfig(ImmutableMap.copyOf(otherConfigsMap));
+ transaction.add(op.mutate(ovs).addMutation(ovs.getOtherConfigColumn().getSchema(),
+ Mutator.INSERT,
+ ovs.getOtherConfigColumn().getData()));
+ } catch (NullPointerException e) {
+ LOG.warn("Incomplete OVSDB Node other_config", e);
+ }
+ }
}
}
}
import org.opendaylight.ovsdb.schema.openvswitch.Bridge;
import org.opendaylight.ovsdb.schema.openvswitch.Interface;
import org.opendaylight.ovsdb.schema.openvswitch.Port;
+import org.opendaylight.ovsdb.southbound.SouthboundConstants;
import org.opendaylight.ovsdb.southbound.SouthboundMapper;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes.VlanMode;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.Options;
public class TerminationPointCreateCommand implements TransactCommand {
private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes;
+ private BridgeOperationalState operationalState;
private static final Logger LOG = LoggerFactory.getLogger(TerminationPointCreateCommand.class);
- public TerminationPointCreateCommand(AsyncDataChangeEvent<InstanceIdentifier<?>,
+ public TerminationPointCreateCommand(BridgeOperationalState state, AsyncDataChangeEvent<InstanceIdentifier<?>,
DataObject> changes) {
+ this.operationalState = state;
this.changes = changes;
}
}
port.setTrunks(portTrunks);
}
+ if (terminationPoint.getVlanMode() != null) {
+ Set<String> portVlanMode = new HashSet<String>();
+ VlanMode modelVlanMode = terminationPoint.getVlanMode();
+ portVlanMode.add(SouthboundConstants.VLANMODES.values()[modelVlanMode.getIntValue() - 1].getMode());
+ port.setVlanMode(portVlanMode);
+ }
List<PortExternalIds> portExternalIds = terminationPoint.getPortExternalIds();
if (portExternalIds != null && !portExternalIds.isEmpty()) {
import java.util.Map;
import java.util.Set;
-import java.util.concurrent.ExecutionException;
-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.AsyncDataChangeEvent;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
-import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
import org.opendaylight.ovsdb.lib.notation.Mutator;
import org.opendaylight.ovsdb.lib.notation.UUID;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import com.google.common.base.Optional;
import com.google.common.collect.Sets;
-import com.google.common.util.concurrent.CheckedFuture;
/**
* @author avishnoi@brocade.com (Anil Vishnoi)
public class TerminationPointDeleteCommand implements TransactCommand {
private static final Logger LOG = LoggerFactory.getLogger(TerminationPointDeleteCommand.class);
private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes;
- private DataBroker db;
+ private BridgeOperationalState opertationalState;
- public TerminationPointDeleteCommand(DataBroker db, AsyncDataChangeEvent<InstanceIdentifier<?>,
+ public TerminationPointDeleteCommand(BridgeOperationalState state, AsyncDataChangeEvent<InstanceIdentifier<?>,
DataObject> changes) {
- this.db = db;
+ this.opertationalState = state;
this.changes = changes;
}
public void execute(TransactionBuilder transaction) {
Map<InstanceIdentifier<OvsdbTerminationPointAugmentation>, OvsdbTerminationPointAugmentation> originals
= TransactUtils.extractOriginal(changes,OvsdbTerminationPointAugmentation.class);
+ Map<InstanceIdentifier<Node>, Node> originalNodes
+ = TransactUtils.extractOriginal(changes,Node.class);
Set<InstanceIdentifier<OvsdbTerminationPointAugmentation>> removedTps
= TransactUtils.extractRemoved(changes, OvsdbTerminationPointAugmentation.class);
for (InstanceIdentifier<OvsdbTerminationPointAugmentation> removedTpIid: removedTps) {
LOG.info("Received request to delete termination point {}",removedTpIid);
OvsdbTerminationPointAugmentation original = originals.get(removedTpIid);
+ Node originalNode = originalNodes.get(removedTpIid.firstIdentifierOf(Node.class));
+ OvsdbBridgeAugmentation originalOvsdbBridgeAugmentation =
+ originalNode.getAugmentation(OvsdbBridgeAugmentation.class);
+ String bridgeName = originalOvsdbBridgeAugmentation != null
+ ? originalOvsdbBridgeAugmentation.getBridgeName().getValue() : "Bridge name not found";
Port port = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(), Port.class,null);
- Optional<UUID> terminationPointUuidOptional = getTerminationPointUUID(removedTpIid);
-
- if (terminationPointUuidOptional.isPresent()) {
- UUID portUuid = terminationPointUuidOptional.get();
- Bridge bridge = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(),
- Bridge.class,null);
- Optional<String> bridgeName = getBridgeName(removedTpIid);
-
- transaction.add(op.delete(port.getSchema())
- .where(port.getUuidColumn().getSchema().opEqual(portUuid)).build());
- transaction.add(op.comment("Port: Deleting " + original.getName()
- + " attached to " + bridgeName));
-
- transaction.add(op.mutate(bridge.getSchema())
- .addMutation(bridge.getPortsColumn().getSchema(),
- Mutator.DELETE, Sets.newHashSet(portUuid))
- .where(bridge.getNameColumn().getSchema().opEqual(bridgeName.get())).build());
-
- transaction.add(op.comment("Bridge: Mutating " + bridgeName.get()
- + " to remove port " + portUuid));
- } else {
- LOG.warn("Unable to delete port {} because it was not found in the operational store, "
- + "and thus we cannot retrieve its UUID", terminationPointUuidOptional.get());
- }
- }
- }
-
- private Optional<UUID> getTerminationPointUUID(InstanceIdentifier<OvsdbTerminationPointAugmentation> iid) {
-
- Optional<UUID> result = Optional.absent();
- ReadOnlyTransaction transaction = db.newReadOnlyTransaction();
- CheckedFuture<Optional<OvsdbTerminationPointAugmentation>, ReadFailedException> future
- = transaction.read(LogicalDatastoreType.OPERATIONAL, iid);
- Optional<OvsdbTerminationPointAugmentation> optional;
- try {
- optional = future.get();
- if (optional.isPresent()) {
- OvsdbTerminationPointAugmentation terminationPoint
- = (OvsdbTerminationPointAugmentation) optional.get();
- if (terminationPoint != null && terminationPoint.getPortUuid() != null) {
- result = Optional.of(new UUID(terminationPoint.getPortUuid().getValue()));
- }
- }
- } catch (InterruptedException e) {
- LOG.warn("Unable to retrieve termination point from operational store",e);
- } catch (ExecutionException e) {
- LOG.warn("Unable to retrieve termination point from operational store",e);
- }
- transaction.close();
- return result;
- }
-
- private Optional<String> getBridgeName(InstanceIdentifier<OvsdbTerminationPointAugmentation> iid) {
-
- Optional<String> result = Optional.absent();
- ReadOnlyTransaction transaction = db.newReadOnlyTransaction();
- InstanceIdentifier<Node> tpOvsdbManagedNodeIid = iid.firstIdentifierOf(Node.class);
- CheckedFuture<Optional<Node>, ReadFailedException> future
- = transaction.read(LogicalDatastoreType.OPERATIONAL, tpOvsdbManagedNodeIid);
- Optional<Node> optional;
- try {
- optional = future.get();
- if (optional.isPresent()) {
- OvsdbBridgeAugmentation bridge = optional.get().getAugmentation(OvsdbBridgeAugmentation.class);
- if (bridge != null && bridge.getBridgeName() != null) {
- result = Optional.of(bridge.getBridgeName().getValue());
+ Optional<OvsdbTerminationPointAugmentation> tpAugmentation =
+ opertationalState.getOvsdbTerminationPointAugmentation(removedTpIid);
+
+ if (tpAugmentation.isPresent()) {
+ OvsdbTerminationPointAugmentation tp = tpAugmentation.get();
+ if (tp.getPortUuid() != null) {
+ UUID portUuid = new UUID(tp.getPortUuid().getValue());
+ Bridge bridge = TyperUtils.getTypedRowWrapper(transaction.getDatabaseSchema(),
+ Bridge.class,null);
+
+ transaction.add(op.delete(port.getSchema())
+ .where(port.getUuidColumn().getSchema().opEqual(portUuid)).build());
+ transaction.add(op.comment("Port: Deleting " + original.getName()
+ + " attached to " + bridgeName));
+
+ transaction.add(op.mutate(bridge.getSchema())
+ .addMutation(bridge.getPortsColumn().getSchema(),
+ Mutator.DELETE, Sets.newHashSet(portUuid))
+ .where(bridge.getNameColumn().getSchema().opEqual(bridgeName)).build());
+
+ transaction.add(op.comment("Bridge: Mutating " + bridgeName
+ + " to remove port " + portUuid));
+ } else {
+ LOG.warn("Unable to delete port {} from bridge {} because it was not found in the operational "
+ + "store, operational store, and thus we cannot retrieve its UUID",
+ bridgeName,original.getName());
}
}
- } catch (InterruptedException e) {
- LOG.warn("Unable to retrieve bridge from operational store",e);
- } catch (ExecutionException e) {
- LOG.warn("Unable to retrieve bridge from operational store",e);
}
- transaction.close();
- return result;
}
}
import java.util.ArrayList;
import java.util.List;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
import org.opendaylight.ovsdb.lib.operations.TransactionBuilder;
import org.opendaylight.yangtools.yang.binding.DataObject;
private List<TransactCommand> commands = new ArrayList<TransactCommand>();
private AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes;
- private DataBroker db;
+ private BridgeOperationalState operationalState;
- public TransactCommandAggregator(DataBroker db,AsyncDataChangeEvent<InstanceIdentifier<?>,
+ public TransactCommandAggregator(BridgeOperationalState state,AsyncDataChangeEvent<InstanceIdentifier<?>,
DataObject> changes) {
- this.db = db;
+ this.operationalState = state;
this.changes = changes;
- commands.add(new BridgeCreateCommand(changes));
- commands.add(new BridgeRemovedCommand(db,changes));
- commands.add(new TerminationPointCreateCommand(changes));
- commands.add(new TerminationPointDeleteCommand(db, changes));
+ commands.add(new BridgeCreateCommand(state,changes));
+ commands.add(new BridgeRemovedCommand(state,changes));
+ commands.add(new TerminationPointCreateCommand(state,changes));
+ commands.add(new TerminationPointDeleteCommand(state, changes));
commands.add(new OvsdbNodeUpdateCommand(changes));
}
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import com.google.common.base.Predicates;
+import com.google.common.collect.Maps;
+
public class TransactUtils {
private static final Logger LOG = LoggerFactory.getLogger(TransactUtils.class);
return result;
}
+ public static <T extends DataObject> Map<InstanceIdentifier<T>, T> extractCreatedOrUpdatedOrRemoved(
+ AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes,
+ Class<T> klazz) {
+ Map<InstanceIdentifier<T>,T> result = extractCreatedOrUpdated(changes,klazz);
+ result.putAll(extractRemovedObjects(changes, klazz));
+ return result;
+ }
+
public static <T extends DataObject> Map<InstanceIdentifier<T>,T> extractOriginal(
AsyncDataChangeEvent<InstanceIdentifier<?>,DataObject> changes,Class<T> klazz) {
return extract(changes.getOriginalData(),klazz);
return result;
}
+ public static <T extends DataObject> Map<InstanceIdentifier<T>, T> extractRemovedObjects(
+ AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changes,
+ Class<T> klazz) {
+ Set<InstanceIdentifier<T>> iids = extractRemoved(changes, klazz);
+ return Maps.filterKeys(extractOriginal(changes, klazz),Predicates.in(iids));
+ }
+
public static <T extends DataObject> Map<InstanceIdentifier<T>,T> extract(
Map<InstanceIdentifier<?>, DataObject> changes, Class<T> klazz) {
Map<InstanceIdentifier<T>,T> result = new HashMap<InstanceIdentifier<T>,T>();
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.DatapathTypeEntryBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.InterfaceTypeEntry;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.InterfaceTypeEntryBuilder;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigs;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.node.attributes.OpenvswitchOtherConfigsBuilder;
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.yang.binding.InstanceIdentifier;
ovsdbNodeBuilder.setOpenvswitchExternalIds(externalIdsList);
}
+ Map<String, String> otherConfigs = openVSwitch.getOtherConfigColumn().getData();
+ if (otherConfigs != null && !otherConfigs.isEmpty()) {
+ Set<String> otherConfigKeys = otherConfigs.keySet();
+ List<OpenvswitchOtherConfigs> otherConfigsList = new ArrayList<OpenvswitchOtherConfigs>();
+ String otherConfigValue;
+ for (String otherConfigKey : otherConfigKeys) {
+ otherConfigValue = otherConfigs.get(otherConfigKey);
+ if (otherConfigKey != null && otherConfigValue != null) {
+ otherConfigsList.add(new OpenvswitchOtherConfigsBuilder()
+ .setOtherConfigKey(otherConfigKey)
+ .setOtherConfigValue(otherConfigValue)
+ .build());
+ }
+ }
+ ovsdbNodeBuilder.setOpenvswitchOtherConfigs(otherConfigsList);
+ }
+
NodeBuilder nodeBuilder = new NodeBuilder();
nodeBuilder.setNodeId(SouthboundMapper.createNodeId(
ovsdbNode.getIp(), ovsdbNode.getPort()));
import org.opendaylight.ovsdb.schema.openvswitch.Interface;
import org.opendaylight.ovsdb.schema.openvswitch.Port;
import org.opendaylight.ovsdb.southbound.OvsdbClientKey;
+import org.opendaylight.ovsdb.southbound.SouthboundConstants;
import org.opendaylight.ovsdb.southbound.SouthboundMapper;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid;
import org.opendaylight.yang.gen.v1.urn.opendaylight.l2.types.rev130827.VlanId;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbBridgeName;
+import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbPortInterfaceAttributes;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentation;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.OvsdbTerminationPointAugmentationBuilder;
import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.ovsdb.rev150105.ovsdb.port._interface.attributes.InterfaceExternalIds;
if (portUUID.equals(port.getUuid())) {
Collection<Long> vlanId = port.getTagColumn().getData();
Set<Long> portTrunks = port.getTrunksColumn().getData();
+ Collection<String> vlanMode = port.getVlanModeColumn().getData();
bridgeName = bridge.getName();
NodeId bridgeId = SouthboundMapper.createManagedNodeId(
getKey(), new OvsdbBridgeName(bridgeName));
ovsdbTerminationPointBuilder.setVlanTag(new VlanId(id));
}
List<Trunks> modelTrunks = new ArrayList<Trunks>();
- for (Long trunk: portTrunks) {
- if (trunk != null) {
- modelTrunks.add(new TrunksBuilder().setTrunk(new VlanId(trunk.intValue())).build());
+ if (!portTrunks.isEmpty()) {
+ for (Long trunk: portTrunks) {
+ if (trunk != null) {
+ modelTrunks.add(new TrunksBuilder()
+ .setTrunk(new VlanId(trunk.intValue())).build());
+ }
+ }
+ ovsdbTerminationPointBuilder.setTrunks(modelTrunks);
+ }
+ if (!vlanMode.isEmpty()) {
+ Iterator<String> itr = vlanMode.iterator();
+ String vlanType = itr.next();
+ if (vlanType.equals(SouthboundConstants.VLANMODES.ACCESS.getMode())) {
+ ovsdbTerminationPointBuilder
+ .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.Access);
+ } else if (vlanType.equals(SouthboundConstants.VLANMODES.NATIVE_TAGGED.getMode())) {
+ ovsdbTerminationPointBuilder
+ .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.NativeTagged);
+ } else if (vlanType.equals(SouthboundConstants.VLANMODES.NATIVE_UNTAGGED.getMode())) {
+ ovsdbTerminationPointBuilder
+ .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.NativeUntagged);
+ } else if (vlanType.equals(SouthboundConstants.VLANMODES.TRUNK.getMode())) {
+ ovsdbTerminationPointBuilder
+ .setVlanMode(OvsdbPortInterfaceAttributes.VlanMode.Trunk);
+ } else {
+ LOG.debug("Invalid vlan mode {}.", vlanType);
}
}
- ovsdbTerminationPointBuilder.setTrunks(modelTrunks);
Map<String, String> portExternalIds = port.getExternalIdsColumn().getData();
if (portExternalIds != null && !portExternalIds.isEmpty()) {
Code Review / ovsdb.git / commitdiff