From: Tomas Cechvala Date: Mon, 18 Apr 2016 15:41:47 +0000 (+0200) Subject: Leaving deprecated API in Neutron-Mapper X-Git-Tag: release/boron~200^2 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=commitdiff_plain;h=511671d40d77611b7ec1289a097bf9a50678feab;p=groupbasedpolicy.git Leaving deprecated API in Neutron-Mapper Implementation of DS listener. All the changes should be learned from DS since upstream Neutron project is deprecating it's OSGI services API. Change-Id: I0648fd0ee46cfa80684598706541696849b79384 Signed-off-by: Tomas Cechvala --- diff --git a/features/pom.xml b/features/pom.xml index c2d61710f..c3544e869 100755 --- a/features/pom.xml +++ b/features/pom.xml @@ -138,7 +138,12 @@ ${neutron.version} xml - + + org.opendaylight.neutron + dummyprovider + ${neutron.version} + + org.opendaylight.faas diff --git a/features/src/main/features/features.xml b/features/src/main/features/features.xml index bcd48f8db..e397abad2 100755 --- a/features/src/main/features/features.xml +++ b/features/src/main/features/features.xml @@ -131,6 +131,7 @@ odl-neutron-service odl-groupbasedpolicy-base odl-groupbasedpolicy-ofoverlay + mvn:org.opendaylight.neutron/dummyprovider/{{VERSION}} mvn:org.opendaylight.groupbasedpolicy/neutron-mapper/{{VERSION}} mvn:org.opendaylight.groupbasedpolicy/neutron-ovsdb/{{VERSION}} mvn:org.opendaylight.groupbasedpolicy/neutron-mapper/{{VERSION}}/xml/config diff --git a/neutron-mapper/src/main/java/org/opendaylight/controller/config/yang/config/neutron_mapper/impl/NeutronMapperModule.java b/neutron-mapper/src/main/java/org/opendaylight/controller/config/yang/config/neutron_mapper/impl/NeutronMapperModule.java index e48646b70..8922794cc 100644 --- a/neutron-mapper/src/main/java/org/opendaylight/controller/config/yang/config/neutron_mapper/impl/NeutronMapperModule.java +++ b/neutron-mapper/src/main/java/org/opendaylight/controller/config/yang/config/neutron_mapper/impl/NeutronMapperModule.java @@ -9,14 +9,12 @@ package org.opendaylight.controller.config.yang.config.neutron_mapper.impl; import org.opendaylight.groupbasedpolicy.neutron.mapper.NeutronMapper; -import org.osgi.framework.BundleContext; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class NeutronMapperModule extends org.opendaylight.controller.config.yang.config.neutron_mapper.impl.AbstractNeutronMapperModule { private final Logger LOG = LoggerFactory.getLogger(NeutronMapperModule.class); - private BundleContext bundleContext; public NeutronMapperModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) { super(identifier, dependencyResolver); @@ -33,7 +31,7 @@ public class NeutronMapperModule extends org.opendaylight.controller.config.yang @Override public java.lang.AutoCloseable createInstance() { - final NeutronMapper neutronMapper = new NeutronMapper(getDataBrokerDependency(), getRpcRegistryDependency(), bundleContext); + final NeutronMapper neutronMapper = new NeutronMapper(getDataBrokerDependency(), getRpcRegistryDependency()); LOG.info("Neutron mapper started."); return new AutoCloseable() { @@ -44,8 +42,4 @@ public class NeutronMapperModule extends org.opendaylight.controller.config.yang }; } - public void setBundleContext(BundleContext bundleContext) { - this.bundleContext = bundleContext; - } - } diff --git a/neutron-mapper/src/main/java/org/opendaylight/controller/config/yang/config/neutron_mapper/impl/NeutronMapperModuleFactory.java b/neutron-mapper/src/main/java/org/opendaylight/controller/config/yang/config/neutron_mapper/impl/NeutronMapperModuleFactory.java index d748780f0..8d9ae820a 100644 --- a/neutron-mapper/src/main/java/org/opendaylight/controller/config/yang/config/neutron_mapper/impl/NeutronMapperModuleFactory.java +++ b/neutron-mapper/src/main/java/org/opendaylight/controller/config/yang/config/neutron_mapper/impl/NeutronMapperModuleFactory.java @@ -31,7 +31,6 @@ public class NeutronMapperModuleFactory extends org.opendaylight.controller.conf @Override public Module createModule(String instanceName, DependencyResolver dependencyResolver, BundleContext bundleContext) { NeutronMapperModule module = (NeutronMapperModule) super.createModule(instanceName, dependencyResolver, bundleContext); - module.setBundleContext(bundleContext); return module; } @@ -42,7 +41,6 @@ public class NeutronMapperModuleFactory extends org.opendaylight.controller.conf public Module createModule(String instanceName, DependencyResolver dependencyResolver, DynamicMBeanWithInstance old, BundleContext bundleContext) throws Exception { NeutronMapperModule module = (NeutronMapperModule) super.createModule(instanceName, dependencyResolver, old, bundleContext); - module.setBundleContext(bundleContext); return module; } diff --git a/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/NeutronMapper.java b/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/NeutronMapper.java index 3c64bd79e..f514f0016 100644 --- a/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/NeutronMapper.java +++ b/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/NeutronMapper.java @@ -17,6 +17,7 @@ import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.sal.binding.api.BindingAwareBroker.RpcRegistration; import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry; import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.NeutronFloatingIpAware; +import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.NeutronListener; import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.NeutronNetworkAware; import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.NeutronNetworkDao; import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.NeutronPortAware; @@ -27,16 +28,24 @@ import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.group.SecGroupDa import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.rule.NeutronGbpMapperServiceImpl; import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.rule.NeutronSecurityRuleAware; import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.rule.SecRuleDao; -import org.opendaylight.neutron.spi.INeutronFloatingIPAware; -import org.opendaylight.neutron.spi.INeutronNetworkAware; -import org.opendaylight.neutron.spi.INeutronPortAware; -import org.opendaylight.neutron.spi.INeutronRouterAware; -import org.opendaylight.neutron.spi.INeutronSecurityGroupAware; -import org.opendaylight.neutron.spi.INeutronSecurityRuleAware; -import org.opendaylight.neutron.spi.INeutronSubnetAware; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.endpoint.rev140421.EndpointService; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.NeutronGbpMapperService; -import org.osgi.framework.BundleContext; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.floatingips.attributes.Floatingips; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.floatingips.attributes.floatingips.Floatingip; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.Routers; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.Router; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.Networks; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network; +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.yang.gen.v1.urn.opendaylight.neutron.secgroups.rev150712.security.groups.attributes.SecurityGroups; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.secgroups.rev150712.security.groups.attributes.security.groups.SecurityGroup; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.secgroups.rev150712.security.rules.attributes.SecurityRules; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.secgroups.rev150712.security.rules.attributes.security.rules.SecurityRule; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.Subnets; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.osgi.framework.ServiceRegistration; public class NeutronMapper implements AutoCloseable { @@ -44,15 +53,15 @@ public class NeutronMapper implements AutoCloseable { private final List> registrations = new ArrayList>(); private final DataBroker dataProvider; private final RpcProviderRegistry providerRegistry; - private final BundleContext context; private final EndpointService epService; private RpcRegistration rpcRegistration; + private NeutronListener neutronListener; - public NeutronMapper(DataBroker dataProvider, RpcProviderRegistry rpcProvider, BundleContext context) { + public NeutronMapper(DataBroker dataProvider, RpcProviderRegistry rpcProvider) { this.dataProvider = checkNotNull(dataProvider); this.providerRegistry = checkNotNull(rpcProvider); - this.context = checkNotNull(context); this.epService = rpcProvider.getRpcService(EndpointService.class); + neutronListener = new NeutronListener(dataProvider); registerAwareProviders(); } @@ -60,40 +69,29 @@ public class NeutronMapper implements AutoCloseable { SecGroupDao secGroupDao = new SecGroupDao(); SecRuleDao secRuleDao = new SecRuleDao(); NeutronNetworkDao networkDao = new NeutronNetworkDao(); - - ServiceRegistration neutronSubnetAwareRegistration = - context.registerService(INeutronSubnetAware.class, new NeutronSubnetAware(dataProvider, networkDao), null); - registrations.add(neutronSubnetAwareRegistration); - NeutronSecurityRuleAware securityRuleAware = new NeutronSecurityRuleAware(dataProvider, secRuleDao, secGroupDao); - ServiceRegistration neutronSecurityRuleAwareRegistration = - context.registerService(INeutronSecurityRuleAware.class, securityRuleAware, null); - registrations.add(neutronSecurityRuleAwareRegistration); - NeutronSecurityGroupAware securityGroupAware = new NeutronSecurityGroupAware(dataProvider, securityRuleAware, secGroupDao); - ServiceRegistration neutronSecurityGroupAwareRegistration = - context.registerService(INeutronSecurityGroupAware.class, securityGroupAware, null); - registrations.add(neutronSecurityGroupAwareRegistration); - - ServiceRegistration neutronNetworkAwareRegistration = context.registerService( - INeutronNetworkAware.class, new NeutronNetworkAware(dataProvider, securityGroupAware, networkDao), null); - registrations.add(neutronNetworkAwareRegistration); - - NeutronPortAware portAware = - new NeutronPortAware(dataProvider, epService, securityRuleAware, securityGroupAware); - ServiceRegistration neutronPortAwareRegistration = - context.registerService(INeutronPortAware.class, portAware, null); - registrations.add(neutronPortAwareRegistration); - - NeutronRouterAware routerAware = new NeutronRouterAware(dataProvider, epService); - ServiceRegistration neutronRouterAwareRegistration = - context.registerService(INeutronRouterAware.class, routerAware, null); - registrations.add(neutronRouterAwareRegistration); - - ServiceRegistration neutronFloatingIpAwareRegistration = context - .registerService(INeutronFloatingIPAware.class, new NeutronFloatingIpAware(dataProvider), null); - registrations.add(neutronFloatingIpAwareRegistration); - + neutronListener.registerMappingProviders( + InstanceIdentifier.builder(Neutron.class).child(Floatingips.class).child(Floatingip.class).build(), + new NeutronFloatingIpAware(dataProvider)); + neutronListener.registerMappingProviders( + InstanceIdentifier.builder(Neutron.class).child(Ports.class).child(Port.class).build(), + new NeutronPortAware(dataProvider, epService, securityRuleAware, securityGroupAware)); + neutronListener.registerMappingProviders( + InstanceIdentifier.builder(Neutron.class).child(Routers.class).child(Router.class).build(), + new NeutronRouterAware(dataProvider, epService)); + neutronListener.registerMappingProviders( + InstanceIdentifier.builder(Neutron.class).child(SecurityRules.class).child(SecurityRule.class).build(), + securityRuleAware); + neutronListener.registerMappingProviders( + InstanceIdentifier.builder(Neutron.class).child(SecurityGroups.class).child(SecurityGroup.class).build(), + securityGroupAware); + neutronListener.registerMappingProviders( + InstanceIdentifier.builder(Neutron.class).child(Subnets.class).child(Subnet.class).build(), + new NeutronSubnetAware(dataProvider, networkDao)); + neutronListener.registerMappingProviders( + InstanceIdentifier.builder(Neutron.class).child(Networks.class).child(Network.class).build(), + new NeutronNetworkAware(dataProvider, securityGroupAware, networkDao)); NeutronGbpMapperService neutronGbpMapperService = new NeutronGbpMapperServiceImpl(dataProvider, securityRuleAware); rpcRegistration = providerRegistry.addRpcImplementation(NeutronGbpMapperService.class, neutronGbpMapperService); } @@ -106,6 +104,10 @@ public class NeutronMapper implements AutoCloseable { for (ServiceRegistration registration : registrations) { registration.unregister(); } + if (neutronListener != null) { + neutronListener.close(); + neutronListener = null; + } rpcRegistration.close(); } diff --git a/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/MappingProcessor.java b/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/MappingProcessor.java new file mode 100644 index 000000000..019fe62a8 --- /dev/null +++ b/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/MappingProcessor.java @@ -0,0 +1,24 @@ +/* + * 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.neutron.mapper.mapping; + +import org.opendaylight.neutron.spi.NeutronObject; +import org.opendaylight.yangtools.yang.binding.DataObject; + +public interface MappingProcessor { + + int canCreate(T t); + int canUpdate(T original, T delta); + int canDelete(T t); + + void updated(T t); + void created(T t); + void deleted(T t); + + T convertToNeutron(D d); +} diff --git a/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/NeutronFloatingIpAware.java b/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/NeutronFloatingIpAware.java index 2650595ba..987ac7966 100644 --- a/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/NeutronFloatingIpAware.java +++ b/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/NeutronFloatingIpAware.java @@ -16,18 +16,18 @@ import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.groupbasedpolicy.neutron.mapper.util.Utils; import org.opendaylight.groupbasedpolicy.util.DataStoreHelper; import org.opendaylight.groupbasedpolicy.util.IidFactory; -import org.opendaylight.neutron.spi.INeutronFloatingIPAware; import org.opendaylight.neutron.spi.NeutronFloatingIP; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L3ContextId; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.l3endpoint.rev151217.NatAddress; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.l3endpoint.rev151217.NatAddressBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.floatingips.attributes.floatingips.Floatingip; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.google.common.base.Strings; -public class NeutronFloatingIpAware implements INeutronFloatingIPAware { +public class NeutronFloatingIpAware implements MappingProcessor { public static final Logger LOG = LoggerFactory.getLogger(NeutronFloatingIpAware.class); private final DataBroker dataProvider; @@ -37,19 +37,45 @@ public class NeutronFloatingIpAware implements INeutronFloatingIPAware { } @Override - public int canCreateFloatingIP(NeutronFloatingIP floatingIP) { - LOG.trace("canCreateFloatingIP - {}", floatingIP); + public NeutronFloatingIP convertToNeutron(Floatingip fip) { + NeutronFloatingIP result = new NeutronFloatingIP(); + result.setID(fip.getUuid().getValue()); + if (fip.getFloatingNetworkId() != null) { + result.setFloatingNetworkUUID(fip.getFloatingNetworkId().getValue()); + } + if (fip.getPortId() != null) { + result.setPortUUID(fip.getPortId().getValue()); + } + if (fip.getFixedIpAddress() != null ) { + result.setFixedIPAddress(String.valueOf(fip.getFixedIpAddress().getValue())); + } + if (fip.getFloatingIpAddress() != null) { + result.setFloatingIPAddress(String.valueOf(fip.getFloatingIpAddress().getValue())); + } + if (fip.getTenantId() != null) { + result.setTenantID(fip.getTenantId()); + } + if (fip.getRouterId() != null) { + result.setRouterUUID(fip.getRouterId().getValue()); + } + result.setStatus(fip.getStatus()); + return result; + } + + @Override + public int canCreate(NeutronFloatingIP floatingIP) { + LOG.trace("canCreate floatingIP - {}", floatingIP); return StatusCode.OK; } @Override - public void neutronFloatingIPCreated(NeutronFloatingIP floatingIP) { - LOG.trace("neutronFloatingIPCreated - {}", floatingIP); + public void created(NeutronFloatingIP floatingIP) { + LOG.trace("created floatinIp - {}", floatingIP); } @Override - public int canUpdateFloatingIP(NeutronFloatingIP delta, NeutronFloatingIP original) { - LOG.trace("canUpdateFloatingIP - delta: {} original: {}", delta, original); + public int canUpdate(NeutronFloatingIP delta, NeutronFloatingIP original) { + LOG.trace("canUpdate floatingIP - delta: {} original: {}", delta, original); String oldFixedIPAddress = Strings.nullToEmpty(original.getFixedIPAddress()); String newFixedIPAddress = Strings.nullToEmpty(delta.getFixedIPAddress()); if (oldFixedIPAddress.equals(newFixedIPAddress)) { @@ -83,19 +109,18 @@ public class NeutronFloatingIpAware implements INeutronFloatingIPAware { } @Override - public void neutronFloatingIPUpdated(NeutronFloatingIP floatingIP) { - LOG.trace("neutronFloatingIPUpdated - {}", floatingIP); + public void updated(NeutronFloatingIP floatingIP) { + LOG.trace("updated floatingIP - {}", floatingIP); } @Override - public int canDeleteFloatingIP(NeutronFloatingIP floatingIP) { - LOG.trace("canDeleteFloatingIP - {}", floatingIP); + public int canDelete(NeutronFloatingIP floatingIP) { + LOG.trace("canDelete floatingIP - {}", floatingIP); return StatusCode.OK; } @Override - public void neutronFloatingIPDeleted(NeutronFloatingIP floatingIP) { - LOG.trace("neutronFloatingIPDeleted - {}", floatingIP); + public void deleted(NeutronFloatingIP floatingIP) { + LOG.trace("deleted floatingIP - {}", floatingIP); } - } diff --git a/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/NeutronListener.java b/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/NeutronListener.java new file mode 100644 index 000000000..f3fa2770b --- /dev/null +++ b/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/NeutronListener.java @@ -0,0 +1,141 @@ +/* + * 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.neutron.mapper.mapping; + +import java.io.Closeable; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Collection; +import java.util.LinkedHashMap; +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.DataObjectModification; +import org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType; +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.neutron.spi.NeutronObject; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron; +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.InstanceIdentifier.PathArgument; + +import com.google.common.collect.Iterators; +import com.google.common.collect.PeekingIterator; + +public class NeutronListener implements DataTreeChangeListener, Closeable { + + private final ListenerRegistration registerDataTreeChangeListener; + private final Map, MappingProcessor> dataChangeProviders = new LinkedHashMap<>(); + private static DataObjectModification neutron; + + public NeutronListener(DataBroker dataProvider) { + registerDataTreeChangeListener = dataProvider.registerDataTreeChangeListener(new DataTreeIdentifier<>( + LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.builder(Neutron.class).build()), this); + } + + @Override + public void onDataTreeChanged(Collection> changes) { + for (DataTreeModification change : changes) { + neutron = change.getRootNode(); + for (InstanceIdentifier iid : dataChangeProviders.keySet()) { + for (DataObjectModification modifDto : findModifiedData(iid, change.getRootNode())) { + processChangedData(modifDto, modifDto.getModificationType(), getMappingProvider(iid)); + } + } + } + } + + /** + * Finds all modified subnodes of given type in {@link Neutron} node. + * + * @param iid path to data in root node + * @param rootNode modified data of {@link Neutron} node + * @return {@link List} of modified subnodes + */ + private List> findModifiedData( + InstanceIdentifier iid, DataObjectModification rootNode) { + List> modDtos = new ArrayList<>(); + PeekingIterator pathArgs = Iterators.peekingIterator(iid.getPathArguments().iterator()); + DataObjectModification modifDto = rootNode; + while (pathArgs.hasNext()) { + pathArgs.next(); + for (DataObjectModification childDto : modifDto.getModifiedChildren()) { + if (pathArgs.hasNext() && childDto.getDataType().equals(pathArgs.peek().getType())) { + if (childDto.getDataType().equals(iid.getTargetType())) { + modDtos.add(childDto); + } else { + modifDto = childDto; + break; + } + } + } + } + return modDtos; + } + + static Neutron getNeutronDataBefore() { + return neutron.getDataBefore(); + } + + static Neutron getNeutronDataAfter() { + return neutron.getDataAfter(); + } + + @SuppressWarnings("unchecked") + void processChangedData(DataObjectModification dto, + ModificationType m, MappingProcessor d) { + switch (m) { + case WRITE: { + T dataAfter = (T) dto.getDataAfter(); + X neutronObject = d.convertToNeutron(dataAfter); + if (StatusCode.OK == d.canCreate(neutronObject)) { + d.created(neutronObject); + } + break; + } + case SUBTREE_MODIFIED: { + X neutronObjectBefore = d.convertToNeutron((T) dto.getDataBefore()); + X neutronObjectAfter = d.convertToNeutron((T) dto.getDataAfter()); + if (StatusCode.OK == d.canUpdate(neutronObjectAfter, neutronObjectBefore)) { + d.updated(neutronObjectAfter); + } + break; + } + case DELETE: { + X neutronObjectBefore = d.convertToNeutron((T) dto.getDataBefore()); + if (StatusCode.OK == d.canDelete(neutronObjectBefore)) { + d.deleted(neutronObjectBefore); + } + break; + } + } + } + + public void registerMappingProviders( + InstanceIdentifier iid, MappingProcessor np) { + dataChangeProviders.put(iid, np); + } + + @SuppressWarnings("unchecked") + MappingProcessor getMappingProvider( + InstanceIdentifier iid) { + return (MappingProcessor) dataChangeProviders.get(iid); + } + + @Override + public void close() throws IOException { + registerDataTreeChangeListener.close(); + } + +} + diff --git a/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/NeutronNetworkAware.java b/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/NeutronNetworkAware.java index 514dbef86..8e218533e 100644 --- a/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/NeutronNetworkAware.java +++ b/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/NeutronNetworkAware.java @@ -9,7 +9,9 @@ package org.opendaylight.groupbasedpolicy.neutron.mapper.mapping; import static com.google.common.base.Preconditions.checkNotNull; +import java.util.ArrayList; import java.util.HashSet; +import java.util.List; import java.util.Set; import java.util.UUID; @@ -27,8 +29,8 @@ import org.opendaylight.groupbasedpolicy.neutron.mapper.util.NeutronUtils; import org.opendaylight.groupbasedpolicy.neutron.mapper.util.Utils; import org.opendaylight.groupbasedpolicy.util.DataStoreHelper; import org.opendaylight.groupbasedpolicy.util.IidFactory; -import org.opendaylight.neutron.spi.INeutronNetworkAware; import org.opendaylight.neutron.spi.NeutronNetwork; +import org.opendaylight.neutron.spi.NeutronNetwork_Segment; import org.opendaylight.neutron.spi.NeutronSecurityGroup; import org.opendaylight.neutron.spi.NeutronSecurityRule; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid; @@ -49,15 +51,25 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev 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.policy.ExternalImplicitGroup; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.ExternalImplicitGroupBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.ext.rev150712.NetworkL3Extension; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.NetworkTypeBase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.NetworkTypeFlat; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.NetworkTypeGre; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.NetworkTypeVlan; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.NetworkTypeVxlan; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.networks.rev150712.networks.attributes.networks.Network; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.provider.ext.rev150712.NetworkProviderExtension; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.provider.ext.rev150712.neutron.networks.network.Segments; 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.Strings; +import com.google.common.collect.ImmutableBiMap; import com.google.common.collect.ImmutableList; -public class NeutronNetworkAware implements INeutronNetworkAware { +public class NeutronNetworkAware implements MappingProcessor { private static final Logger LOG = LoggerFactory.getLogger(NeutronNetworkAware.class); private final DataBroker dataProvider; @@ -71,22 +83,56 @@ public class NeutronNetworkAware implements INeutronNetworkAware { this.networkDao = checkNotNull(networkDao); } - /** - * @see org.opendaylight.neutron.spi.INeutronNetworkAware#canCreateNetwork(org.opendaylight.neutron.spi.NeutronNetwork) - */ + private static final ImmutableBiMap,String> NETWORK_MAP + = new ImmutableBiMap.Builder,String>() + .put(NetworkTypeFlat.class,"flat") + .put(NetworkTypeGre.class,"gre") + .put(NetworkTypeVlan.class,"vlan") + .put(NetworkTypeVxlan.class,"vxlan") + .build(); + + @Override + public NeutronNetwork convertToNeutron(Network network) { + NeutronNetwork result = new NeutronNetwork(); + result.initDefaults(); + result.setAdminStateUp(network.isAdminStateUp()); + result.setNetworkName(network.getName()); + result.setShared(network.isShared()); + result.setStatus(network.getStatus()); + result.setTenantID(network.getTenantId()); + result.setID(network.getUuid().getValue()); + + NetworkL3Extension l3Extension = network.getAugmentation(NetworkL3Extension.class); + result.setRouterExternal(l3Extension.isExternal()); + + NetworkProviderExtension providerExtension = network.getAugmentation(NetworkProviderExtension.class); + result.setProviderPhysicalNetwork(providerExtension.getPhysicalNetwork()); + result.setProviderSegmentationID(providerExtension.getSegmentationId()); + result.setProviderNetworkType(NETWORK_MAP.get(providerExtension.getNetworkType())); + List segments = new ArrayList(); + if (providerExtension.getSegments() != null) { + for (Segments segment: providerExtension.getSegments()) { + NeutronNetwork_Segment neutronSegment = new NeutronNetwork_Segment(); + neutronSegment.setProviderPhysicalNetwork(segment.getPhysicalNetwork()); + neutronSegment.setProviderSegmentationID(segment.getSegmentationId()); + neutronSegment.setProviderNetworkType(NETWORK_MAP.get(segment.getNetworkType())); + segments.add(neutronSegment); + } + } + result.setSegments(segments); + return result; + } + @Override - public int canCreateNetwork(NeutronNetwork network) { - LOG.trace("canCreateNetwork - {}", network); + public int canCreate(NeutronNetwork network) { + LOG.trace("canCreate network - {}", network); // nothing to consider return StatusCode.OK; } - /** - * @see org.opendaylight.neutron.spi.INeutronNetworkAware#neutronNetworkCreated(org.opendaylight.neutron.spi.NeutronNetwork) - */ @Override - public void neutronNetworkCreated(NeutronNetwork network) { - LOG.trace("neutronNetworkCreated - {}", network); + public void created(NeutronNetwork network) { + LOG.trace("created network - {}", network); ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction(); L2FloodDomainId l2FdId = new L2FloodDomainId(network.getID()); TenantId tenantId = new TenantId(Utils.normalizeUuid(network.getTenantID())); @@ -190,42 +236,29 @@ public class NeutronNetworkAware implements INeutronNetworkAware { NeutronGbpIidFactory.providerPhysicalNetworkAsL2FloodDomainIid(tenantId, l2FdId), provNetAsL2Fd); } - /** - * @see org.opendaylight.neutron.spi.INeutronNetworkAware#canUpdateNetwork(org.opendaylight.neutron.spi.NeutronNetwork, - * org.opendaylight.neutron.spi.NeutronNetwork) - */ @Override - public int canUpdateNetwork(NeutronNetwork delta, NeutronNetwork original) { - LOG.trace("canUpdateNetwork - delta: {} original: {}", delta, original); + public int canUpdate(NeutronNetwork delta, NeutronNetwork original) { + LOG.trace("canUpdate network - delta: {} original: {}", delta, original); // nothing to consider return StatusCode.OK; } - /** - * @see org.opendaylight.neutron.spi.INeutronNetworkAware#neutronNetworkUpdated(org.opendaylight.neutron.spi.NeutronNetwork) - */ @Override - public void neutronNetworkUpdated(NeutronNetwork network) { - LOG.trace("neutronNetworkUpdated - {}", network); + public void updated(NeutronNetwork network) { + LOG.trace("updated network - {}", network); // TODO we could update just name } - /** - * @see org.opendaylight.neutron.spi.INeutronNetworkAware#canDeleteNetwork(org.opendaylight.neutron.spi.NeutronNetwork) - */ @Override - public int canDeleteNetwork(NeutronNetwork network) { - LOG.trace("canDeleteNetwork - {}", network); + public int canDelete(NeutronNetwork network) { + LOG.trace("canDelete network - {}", network); // nothing to consider return StatusCode.OK; } - /** - * @see org.opendaylight.neutron.spi.INeutronNetworkAware#neutronNetworkDeleted(org.opendaylight.neutron.spi.NeutronNetwork) - */ @Override - public void neutronNetworkDeleted(NeutronNetwork network) { - LOG.trace("neutronNetworkDeleted - {}", network); + public void deleted(NeutronNetwork network) { + LOG.trace("deleted network - {}", network); ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction(); TenantId tenantId = new TenantId(Utils.normalizeUuid(network.getTenantID())); L2FloodDomainId l2FdId = new L2FloodDomainId(network.getID()); diff --git a/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/NeutronPortAware.java b/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/NeutronPortAware.java index 5c19ea5a9..84acfb80c 100644 --- a/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/NeutronPortAware.java +++ b/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/NeutronPortAware.java @@ -30,14 +30,19 @@ import org.opendaylight.groupbasedpolicy.neutron.mapper.util.MappingUtils.Forwar import org.opendaylight.groupbasedpolicy.neutron.mapper.util.Utils; import org.opendaylight.groupbasedpolicy.util.DataStoreHelper; import org.opendaylight.groupbasedpolicy.util.IidFactory; -import org.opendaylight.neutron.spi.INeutronPortAware; import org.opendaylight.neutron.spi.NeutronPort; +import org.opendaylight.neutron.spi.NeutronPort_AllowedAddressPairs; +import org.opendaylight.neutron.spi.NeutronPort_ExtraDHCPOption; +import org.opendaylight.neutron.spi.NeutronPort_VIFDetail; +import org.opendaylight.neutron.spi.NeutronRouter; +import org.opendaylight.neutron.spi.NeutronRouter_Interface; import org.opendaylight.neutron.spi.NeutronSecurityGroup; import org.opendaylight.neutron.spi.NeutronSecurityRule; import org.opendaylight.neutron.spi.Neutron_IPs; 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.ietf.params.xml.ns.yang.ietf.yang.types.rev130715.Uuid; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2FloodDomainId; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L3ContextId; @@ -70,6 +75,13 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gb import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.external.gateways.as.l3.endpoints.ExternalGatewayAsL3Endpoint; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.ports.by.endpoints.PortByEndpoint; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.EndpointGroup; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.binding.rev150712.PortBindingExtension; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.binding.rev150712.binding.attributes.VifDetails; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.AllowedAddressPairs; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.ExtraDhcpOpts; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.port.attributes.FixedIps; +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.yangtools.yang.binding.InstanceIdentifier; import org.opendaylight.yangtools.yang.common.RpcResult; import org.slf4j.Logger; @@ -80,8 +92,9 @@ import com.google.common.base.Optional; import com.google.common.base.Strings; import com.google.common.collect.Collections2; import com.google.common.collect.ImmutableList; +import com.google.common.collect.Lists; -public class NeutronPortAware implements INeutronPortAware { +public class NeutronPortAware implements MappingProcessor { public static final Logger LOG = LoggerFactory.getLogger(NeutronPortAware.class); private static final String DEVICE_OWNER_DHCP = "network:dhcp"; @@ -100,36 +113,130 @@ public class NeutronPortAware implements INeutronPortAware { this.secGrpAware = secGrpAware; } - /** - * @see org.opendaylight.neutron.spi.INeutronPortAware#canCreatePort(org.opendaylight.neutron.spi.NeutronPort) - */ @Override - public int canCreatePort(NeutronPort port) { - LOG.trace("canCreatePort - {}", port); + public NeutronPort convertToNeutron(Port port) { + return toNeutron(port); + } + + static NeutronPort toNeutron(Port port) { + NeutronPort result = new NeutronPort(); + result.setAdminStateUp(port.isAdminStateUp()); + if (port.getAllowedAddressPairs() != null) { + List pairs = new ArrayList(); + for (AllowedAddressPairs mdPair : port.getAllowedAddressPairs()) { + NeutronPort_AllowedAddressPairs pair = new NeutronPort_AllowedAddressPairs(); + pair.setIpAddress(mdPair.getIpAddress()); + pair.setMacAddress(mdPair.getMacAddress()); + pairs.add(pair); + } + result.setAllowedAddressPairs(pairs); + } + result.setDeviceID(port.getDeviceId()); + result.setDeviceOwner(port.getDeviceOwner()); + if (port.getExtraDhcpOpts() != null) { + List options = new ArrayList(); + for (ExtraDhcpOpts opt : port.getExtraDhcpOpts()) { + NeutronPort_ExtraDHCPOption arg = new NeutronPort_ExtraDHCPOption(); + arg.setName(opt.getOptName()); + arg.setValue(opt.getOptValue()); + arg.setIpVersion(NeutronSubnetAware.IPV_MAP.get(opt.getIpVersion())); + options.add(arg); + } + result.setExtraDHCPOptions(options); + } + if (port.getFixedIps() != null) { + List ips = new ArrayList(); + for (FixedIps mdIP : port.getFixedIps()) { + Neutron_IPs ip = new Neutron_IPs(); + ip.setIpAddress(String.valueOf(mdIP.getIpAddress().getValue())); + ip.setSubnetUUID(mdIP.getSubnetId().getValue()); + ips.add(ip); + } + result.setFixedIPs(ips); + } + result.setMacAddress(port.getMacAddress()); + result.setName(port.getName()); + result.setNetworkUUID(port.getNetworkId().getValue()); + if(port.getSecurityGroups() != null) { + result.setSecurityGroups(Lists.transform(port.getSecurityGroups(), + new Function() { + + @Override + public NeutronSecurityGroup apply(Uuid uuid) { + NeutronSecurityGroup sg = new NeutronSecurityGroup(); + sg.setID(uuid.getValue()); + return sg; + } + })); + } + result.setStatus(port.getStatus()); + if (port.getTenantId() != null) { + result.setTenantID(port.getTenantId()); + } + result.setID(port.getUuid().getValue()); + addExtensions(port, result); + return result; + } + + protected static void addExtensions(Port port, NeutronPort result) { + PortBindingExtension binding = port.getAugmentation(PortBindingExtension.class); + result.setBindinghostID(binding.getHostId()); + if (binding.getVifDetails() != null) { + List details = new ArrayList(); + for (VifDetails vifDetail : binding.getVifDetails()) { + NeutronPort_VIFDetail detail = new NeutronPort_VIFDetail(); + detail.setPortFilter(vifDetail.isPortFilter()); + detail.setOvsHybridPlug(vifDetail.isOvsHybridPlug()); + details.add(detail); + } + result.setVIFDetail(details); + } + result.setBindingvifType(binding.getVifType()); + result.setBindingvnicType(binding.getVnicType()); + } + + @Override + public int canCreate(NeutronPort port) { + LOG.trace("canCreate port - {}", port); // TODO Li msunal this has to be rewrite when OFOverlay renderer will support l3-endpoints. List fixedIPs = port.getFixedIPs(); if (fixedIPs != null && fixedIPs.size() > 1) { LOG.warn("Neutron mapper does not support multiple IPs on the same port."); return StatusCode.BAD_REQUEST; } + NeutronRouter router = (isRouterGatewayPort(port) || isRouterInterfacePort(port)) ? NeutronRouterAware.getRouterForPort(port.getDeviceID()) : null; + if (router != null) { + return NeutronRouterAware.canAttachInterface(router, createNeutronRouter_InterfaceFrom(port), dataProvider); + } return StatusCode.OK; } - /** - * @see org.opendaylight.neutron.spi.INeutronPortAware#neutronPortCreated(org.opendaylight.neutron.spi.NeutronPort) - */ - @Override - public void neutronPortCreated(NeutronPort port) { - LOG.trace("neutronPortCreated - {}", port); - if (isRouterInterfacePort(port)) { - LOG.trace("Port is router interface - {} does nothing. {} handles router iface.", - NeutronPortAware.class.getSimpleName(), NeutronRouterAware.class.getSimpleName()); - return; + private static NeutronRouter_Interface createNeutronRouter_InterfaceFrom(NeutronPort port) { + NeutronRouter_Interface nri = new NeutronRouter_Interface(); + if (port.getID() != null) { + nri.setID(port.getID()); + nri.setPortUUID(port.getID()); } - if (isRouterGatewayPort(port)) { - LOG.trace("Port is router gateway - {} does nothing. {} handles router iface.", - NeutronPortAware.class.getSimpleName(), NeutronRouterAware.class.getSimpleName()); - return; + if (port.getTenantID() != null) { + nri.setTenantID(port.getTenantID()); + } + if (port.getFixedIPs() != null && port.getFixedIPs().size() == 1) { + // supported case + nri.setSubnetUUID(port.getFixedIPs().get(0).getSubnetUUID()); + } + return nri; + } + + @Override + public void created(NeutronPort port) { + LOG.trace("created port - {}", port); + if (isRouterInterfacePort(port) || isRouterGatewayPort(port)) { + NeutronRouter router = NeutronRouterAware.getRouterForPort(port.getDeviceID()); + if (router != null) { + NeutronRouterAware.neutronRouterInterfaceAttached(router, createNeutronRouter_InterfaceFrom(port), + dataProvider, epService); + return; + } } if (isFloatingIpPort(port)) { LOG.trace("Port is floating ip - {} device id - {}", port.getID(), port.getDeviceID()); @@ -278,13 +385,9 @@ public class NeutronPortAware implements INeutronPortAware { return true; } - /** - * @see org.opendaylight.neutron.spi.INeutronPortAware#canUpdatePort(org.opendaylight.neutron.spi.NeutronPort, - * org.opendaylight.neutron.spi.NeutronPort) - */ @Override - public int canUpdatePort(NeutronPort delta, NeutronPort original) { - LOG.trace("canUpdatePort - delta: {} original: {}", delta, original); + public int canUpdate(NeutronPort delta, NeutronPort original) { + LOG.trace("catUpdate port - delta: {} original: {}", delta, original); if (delta.getFixedIPs() == null || delta.getFixedIPs().isEmpty()) { return StatusCode.OK; } @@ -294,23 +397,46 @@ public class NeutronPortAware implements INeutronPortAware { LOG.warn("Neutron mapper does not support multiple IPs on the same port."); return StatusCode.BAD_REQUEST; } + boolean wasRouterPort = isRouterGatewayPort(original) || isRouterInterfacePort(original); + boolean isRouterPort = isRouterGatewayPort(delta) || isRouterInterfacePort(delta); + if (wasRouterPort || isRouterPort) { + NeutronRouter router = NeutronRouterAware.getRouterForPort(delta.getDeviceID()); + if (router != null && !wasRouterPort && isRouterPort) { + return NeutronRouterAware. + canAttachInterface(router, createNeutronRouter_InterfaceFrom(delta), dataProvider); + } else if (router != null && wasRouterPort && !isRouterPort) { + return NeutronRouterAware.canDetachInterface(router, createNeutronRouter_InterfaceFrom(delta)); + } + } return StatusCode.OK; } - /** - * @see org.opendaylight.neutron.spi.INeutronPortAware#neutronPortUpdated(org.opendaylight.neutron.spi.NeutronPort) - */ @Override - public void neutronPortUpdated(NeutronPort port) { - LOG.trace("neutronPortUpdated - {}", port); - if (isRouterInterfacePort(port)) { - LOG.trace("Port is router interface - {} does nothing. {} handles router iface.", - NeutronPortAware.class.getSimpleName(), NeutronRouterAware.class.getSimpleName()); - return; + public void updated(NeutronPort port) { + LOG.trace("updated port - {}", port); + NeutronPort original = null; + Ports ports = NeutronListener.getNeutronDataBefore().getPorts(); + boolean wasRouterPort = false; + if (ports != null) { + for (Port p : ports.getPort()) { + if (p.getUuid().getValue().equals(port.getID())) { + original = toNeutron(p); + wasRouterPort = isRouterGatewayPort(original) || isRouterInterfacePort(original); + } + } } - if (isRouterGatewayPort(port)) { - LOG.trace("Port is router gateway - {}", port.getID()); - return; + boolean isRouterPort = isRouterGatewayPort(port) || isRouterInterfacePort(port); + if (original != null && (wasRouterPort || isRouterPort)) { + NeutronRouter router = NeutronRouterAware.getRouterForPort(port.getDeviceID()); + if (router != null && (!wasRouterPort && isRouterPort)) { + NeutronRouterAware.neutronRouterInterfaceAttached(router, createNeutronRouter_InterfaceFrom(port), + dataProvider, epService); + return; + } else if (router != null && (wasRouterPort && !isRouterPort)) { + NeutronRouterAware.neutronRouterInterfaceAttached(router, createNeutronRouter_InterfaceFrom(port), + dataProvider, epService); + return; + } } if (isFloatingIpPort(port)) { LOG.trace("Port is floating ip - {}", port.getID()); @@ -409,31 +535,26 @@ public class NeutronPortAware implements INeutronPortAware { return true; } - /** - * @see org.opendaylight.neutron.spi.INeutronPortAware#canDeletePort(org.opendaylight.neutron.spi.NeutronPort) - */ @Override - public int canDeletePort(NeutronPort port) { - LOG.trace("canDeletePort - {}", port); - // nothing to consider + public int canDelete(NeutronPort port) { + LOG.trace("canDelete port - {}", port); + NeutronRouter router = (isRouterGatewayPort(port) || isRouterInterfacePort(port)) ? NeutronRouterAware.getRouterForPort(port.getDeviceID()) : null; + if (router != null) { + return NeutronRouterAware.canDetachInterface(router, createNeutronRouter_InterfaceFrom(port)); + } return StatusCode.OK; } - /** - * @see org.opendaylight.neutron.spi.INeutronPortAware#neutronPortDeleted(org.opendaylight.neutron.spi.NeutronPort) - */ @Override - public void neutronPortDeleted(NeutronPort port) { - LOG.trace("neutronPortDeleted - {}", port); - if (isRouterInterfacePort(port)) { - LOG.trace("Port is router interface - {} does nothing. {} handles router iface.", - NeutronPortAware.class.getSimpleName(), NeutronRouterAware.class.getSimpleName()); - return; - } - if (isRouterGatewayPort(port)) { - LOG.trace("Port is router gateway - {} does nothing. {} handles router iface.", - NeutronPortAware.class.getSimpleName(), NeutronRouterAware.class.getSimpleName()); - return; + public void deleted(NeutronPort port) { + LOG.trace("deleted port - {}", port); + if (isRouterInterfacePort(port) || isRouterGatewayPort(port)) { + NeutronRouter router = NeutronRouterAware.getRouterForPort(port.getDeviceID()); + if (router != null) { + NeutronRouterAware.neutronRouterInterfaceDetached(router, createNeutronRouter_InterfaceFrom(port), + dataProvider, epService); + return; + } } if (isFloatingIpPort(port)) { LOG.trace("Port is floating ip - {} device id - {}", port.getID(), port.getDeviceID()); @@ -609,5 +730,4 @@ public class NeutronPortAware implements INeutronPortAware { } return l3s; } - } diff --git a/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/NeutronRouterAware.java b/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/NeutronRouterAware.java index c448f7483..057001ecd 100644 --- a/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/NeutronRouterAware.java +++ b/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/NeutronRouterAware.java @@ -11,7 +11,9 @@ package org.opendaylight.groupbasedpolicy.neutron.mapper.mapping; import static com.google.common.base.Preconditions.checkNotNull; import java.util.ArrayList; +import java.util.HashMap; import java.util.List; +import java.util.Map; import javax.annotation.Nonnull; import javax.annotation.Nullable; @@ -28,13 +30,13 @@ import org.opendaylight.groupbasedpolicy.neutron.mapper.util.Utils; import org.opendaylight.groupbasedpolicy.util.DataStoreHelper; import org.opendaylight.groupbasedpolicy.util.IidFactory; import org.opendaylight.neutron.spi.INeutronPortCRUD; -import org.opendaylight.neutron.spi.INeutronRouterAware; import org.opendaylight.neutron.spi.INeutronSubnetCRUD; import org.opendaylight.neutron.spi.NeutronCRUDInterfaces; import org.opendaylight.neutron.spi.NeutronPort; import org.opendaylight.neutron.spi.NeutronRoute; import org.opendaylight.neutron.spi.NeutronRouter; import org.opendaylight.neutron.spi.NeutronRouter_Interface; +import org.opendaylight.neutron.spi.NeutronRouter_NetworkReference; import org.opendaylight.neutron.spi.NeutronSubnet; import org.opendaylight.neutron.spi.Neutron_IPs; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress; @@ -57,6 +59,14 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev 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.neutron.l3.rev150712.l3.attributes.Routes; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.Routers; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.Router; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.router.Interfaces; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.l3.rev150712.routers.attributes.routers.router.external_gateway_info.ExternalFixedIps; +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.subnets.rev150712.subnets.attributes.Subnets; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -65,7 +75,7 @@ import com.google.common.base.Optional; import com.google.common.base.Strings; import com.google.common.collect.ImmutableList; -public class NeutronRouterAware implements INeutronRouterAware { +public class NeutronRouterAware implements MappingProcessor { private static final Logger LOG = LoggerFactory.getLogger(NeutronRouterAware.class); private static final String DEFAULT_ROUTE = "0.0.0.0/0"; @@ -78,28 +88,86 @@ public class NeutronRouterAware implements INeutronRouterAware { } @Override - public int canCreateRouter(NeutronRouter router) { - LOG.trace("canCreateRouter - {}", router); + public NeutronRouter convertToNeutron(Router router) { + return toNeutron(router); + } + + private static NeutronRouter toNeutron(Router router) { + NeutronRouter result = new NeutronRouter(); + result.setID(router.getUuid().getValue()); + result.setName(router.getName()); + result.setTenantID(router.getTenantId()); + result.setAdminStateUp(router.isAdminStateUp()); + result.setStatus(router.getStatus()); + result.setDistributed(router.isDistributed()); + if (router.getGatewayPortId() != null) { + result.setGatewayPortId(router.getGatewayPortId().getValue()); + } + if (router.getRoutes() != null) { + List routes = new ArrayList(); + for (Routes route : router.getRoutes()) { + NeutronRoute routerRoute = new NeutronRoute(); + routerRoute.setDestination(String.valueOf(route.getDestination().getValue())); + routerRoute.setNextHop(String.valueOf(route.getNexthop().getValue())); + routes.add(routerRoute); + } + result.setRoutes(routes); + } + if (router.getExternalGatewayInfo() != null) { + NeutronRouter_NetworkReference extGwInfo = new NeutronRouter_NetworkReference(); + extGwInfo.setNetworkID(router.getExternalGatewayInfo().getExternalNetworkId().getValue()); + extGwInfo.setEnableSNAT(router.getExternalGatewayInfo().isEnableSnat()); + if (router.getExternalGatewayInfo().getExternalFixedIps() != null) { + List fixedIPs = new ArrayList(); + for (ExternalFixedIps mdFixedIP : router.getExternalGatewayInfo().getExternalFixedIps()) { + Neutron_IPs fixedIP = new Neutron_IPs(); + fixedIP.setSubnetUUID(mdFixedIP.getSubnetId().getValue()); + fixedIP.setIpAddress(String.valueOf(mdFixedIP.getIpAddress().getValue())); + fixedIPs.add(fixedIP); + } + extGwInfo.setExternalFixedIPs(fixedIPs); + } + result.setExternalGatewayInfo(extGwInfo); + } + if (router.getInterfaces() != null) { + Map interfaces = new HashMap(); + for (Interfaces mdInterface : router.getInterfaces()) { + NeutronRouter_Interface pojoInterface = new NeutronRouter_Interface(); + String id = mdInterface.getUuid().getValue(); + pojoInterface.setID(id); + pojoInterface.setTenantID(mdInterface.getTenantId()); + pojoInterface.setSubnetUUID(mdInterface.getSubnetId().getValue()); + pojoInterface.setPortUUID(mdInterface.getPortId().getValue()); + interfaces.put(id, pojoInterface); + } + result.setInterfaces(interfaces); + } + return result; + } + + @Override + public int canCreate(NeutronRouter router) { + LOG.trace("canCreate router - {}", router); // nothing to consider return StatusCode.OK; } @Override - public void neutronRouterCreated(NeutronRouter router) { - LOG.trace("neutronRouterCreated - {}", router); + public void created(NeutronRouter router) { + LOG.trace("created router - {}", router); // TODO Li msunal external gateway } @Override - public int canUpdateRouter(NeutronRouter delta, NeutronRouter original) { - LOG.trace("canUpdateRouter - delta: {} original: {}", delta, original); + public int canUpdate(NeutronRouter delta, NeutronRouter original) { + LOG.trace("canUpdate router - delta: {} original: {}", delta, original); // TODO Li msunal external gateway return StatusCode.OK; } @Override - public void neutronRouterUpdated(NeutronRouter router) { - LOG.trace("neutronRouterUpdated - {}", router); + public void updated(NeutronRouter router) { + LOG.trace("updated router - {}", router); if (router.getExternalGatewayInfo() == null || router.getExternalGatewayInfo().getExternalFixedIPs() == null) { LOG.trace("neutronRouterUpdated - not an external Gateway"); return; @@ -182,7 +250,7 @@ public class NeutronRouterAware implements INeutronRouterAware { routerPort.setTenantID(router.getTenantID()); } - boolean isSuccessful = setNewL3ContextToEpsFromSubnet(tenantId, l3Context, subnet, rwTx); + boolean isSuccessful = setNewL3ContextToEpsFromSubnet(tenantId, l3Context, subnet, rwTx, epService); if (!isSuccessful) { rwTx.cancel(); return; @@ -193,19 +261,19 @@ public class NeutronRouterAware implements INeutronRouterAware { } @Override - public int canDeleteRouter(NeutronRouter router) { - LOG.trace("canDeleteRouter - {}", router); + public int canDelete(NeutronRouter router) { + LOG.trace("canDelete router - {}", router); // nothing to consider return StatusCode.OK; } @Override - public void neutronRouterDeleted(NeutronRouter router) { - LOG.trace("neutronRouterDeleted - {}", router); + public void deleted(NeutronRouter router) { + LOG.trace("deleted router - {}", router); } - @Override - public int canAttachInterface(NeutronRouter router, NeutronRouter_Interface routerInterface) { + + static int canAttachInterface(NeutronRouter router, NeutronRouter_Interface routerInterface, DataBroker dataProvider) { LOG.trace("canAttachInterface - router: {} interface: {}", router, routerInterface); try (ReadOnlyTransaction rTx = dataProvider.newReadOnlyTransaction()) { L3ContextId l3ContextIdFromRouterId = new L3ContextId(router.getID()); @@ -229,16 +297,20 @@ public class NeutronRouterAware implements INeutronRouterAware { } } - @Override - public void neutronRouterInterfaceAttached(NeutronRouter router, NeutronRouter_Interface routerInterface) { - LOG.trace("neutronRouterInterfaceAttached - router: {} interface: {}", router, routerInterface); - NeutronCRUDInterfaces neutronCRUDInterface = new NeutronCRUDInterfaces().fetchINeutronPortCRUD(this); - INeutronPortCRUD portInterface = neutronCRUDInterface.getPortInterface(); - if (portInterface == null) { - LOG.warn("Illegal state - No provider for {}", INeutronPortCRUD.class.getName()); - return; + static NeutronRouter getRouterForPort(String uuid) { + Routers routers = NeutronListener.getNeutronDataAfter().getRouters(); + if (routers != null) { + for (Router router : routers.getRouter()) { + if (router.getUuid().getValue().equals(uuid)) { + return toNeutron(router); + } + } } + return null; + } + static void neutronRouterInterfaceAttached(NeutronRouter router, NeutronRouter_Interface routerInterface, DataBroker dataProvider, EndpointService epService) { + LOG.trace("neutronRouterInterfaceAttached - router: {} interface: {}", router, routerInterface); ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction(); TenantId tenantId = new TenantId(Utils.normalizeUuid(router.getTenantID())); L3ContextId l3ContextIdFromRouterId = new L3ContextId(router.getID()); @@ -253,10 +325,22 @@ public class NeutronRouterAware implements INeutronRouterAware { l3Context = createL3ContextFromRouter(router); rwTx.put(LogicalDatastoreType.CONFIGURATION, l3ContextIidForRouterId, l3Context); } - // Based on Neutron Northbound - Port representing router interface // contains exactly on fixed IP - NeutronPort routerPort = portInterface.getPort(routerInterface.getPortUUID()); + NeutronPort routerPort = null; + Ports ports = NeutronListener.getNeutronDataAfter().getPorts(); + if(ports != null) { + for(Port port : ports.getPort()) { + if(port.getUuid().getValue().equals(routerInterface.getPortUUID())) { + routerPort = NeutronPortAware.toNeutron(port); + break; + } + } + } + if (routerPort == null) { + rwTx.cancel(); + return; + } SubnetId subnetId = new SubnetId(routerInterface.getSubnetUUID()); IpAddress ipAddress = Utils.createIpAddress(routerPort.getFixedIPs().get(0).getIpAddress()); Subnet subnet = resolveSubnetWithVirtualRouterIp(tenantId, subnetId, ipAddress, rwTx); @@ -266,7 +350,7 @@ public class NeutronRouterAware implements INeutronRouterAware { } rwTx.put(LogicalDatastoreType.CONFIGURATION, IidFactory.subnetIid(tenantId, subnet.getId()), subnet); - boolean isSuccessful = setNewL3ContextToEpsFromSubnet(tenantId, l3Context, subnet, rwTx); + boolean isSuccessful = setNewL3ContextToEpsFromSubnet(tenantId, l3Context, subnet, rwTx, epService); if (!isSuccessful) { rwTx.cancel(); return; @@ -286,7 +370,7 @@ public class NeutronRouterAware implements INeutronRouterAware { .build(); } - private @Nullable Subnet resolveSubnetWithVirtualRouterIp(TenantId tenantId, SubnetId subnetId, + private static @Nullable Subnet resolveSubnetWithVirtualRouterIp(TenantId tenantId, SubnetId subnetId, IpAddress ipAddress, ReadTransaction rTx) { Optional potentialSubnet = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, IidFactory.subnetIid(tenantId, subnetId), rTx); @@ -300,8 +384,8 @@ public class NeutronRouterAware implements INeutronRouterAware { return new SubnetBuilder(potentialSubnet.get()).setVirtualRouterIp(ipAddress).build(); } - public boolean setNewL3ContextToEpsFromSubnet(TenantId tenantId, L3Context l3Context, Subnet subnet, - ReadWriteTransaction rwTx) { + public static boolean setNewL3ContextToEpsFromSubnet(TenantId tenantId, L3Context l3Context, Subnet subnet, + ReadWriteTransaction rwTx, EndpointService epService) { if (subnet.getParent() == null) { LOG.warn("Illegal state - subnet {} does not have a parent.", subnet.getId().getValue()); return false; @@ -319,32 +403,34 @@ public class NeutronRouterAware implements INeutronRouterAware { rwTx.put(LogicalDatastoreType.CONFIGURATION, IidFactory.l2BridgeDomainIid(tenantId, l2BridgeDomain.getId()), l2BridgeDomain); - NeutronCRUDInterfaces neutronCRUDInterface = new NeutronCRUDInterfaces().fetchINeutronSubnetCRUD(this); - INeutronSubnetCRUD subnetInterface = neutronCRUDInterface.getSubnetInterface(); - if (subnetInterface == null) { - LOG.warn("Illegal state - No provider for {}", INeutronSubnetCRUD.class.getName()); - return false; - } - List l3Eps = new ArrayList<>(); L3ContextId oldL3ContextId = fwCtx.getL3Context().getId(); - NeutronSubnet neutronSubnet = subnetInterface.getSubnet(subnet.getId().getValue()); - List portsInNeutronSubnet = neutronSubnet.getPortsInSubnet(); - for (NeutronPort port : portsInNeutronSubnet) { - if (NeutronPortAware.isRouterGatewayPort(port) || NeutronPortAware.isRouterInterfacePort(port)) { - continue; - } - boolean isPortAdded = NeutronPortAware.addNeutronPort(port, rwTx, epService); - if (!isPortAdded) { - return false; + NeutronSubnet neutronSubnet = new NeutronSubnet(); + Subnets subnets = NeutronListener.getNeutronDataAfter().getSubnets(); + for(org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet s : subnets.getSubnet()) { + if(s.getUuid().getValue().equals(subnet.getId().getValue())) { + neutronSubnet = NeutronSubnetAware.toNeutron(s); + break; + } } - // TODO Li msunal this has to be rewrite when OFOverlay renderer - // will support l3-endpoints. - Neutron_IPs firstIp = MappingUtils.getFirstIp(port.getFixedIPs()); - if (firstIp != null) { - l3Eps.add(new L3Builder().setL3Context(oldL3ContextId) - .setIpAddress(Utils.createIpAddress(firstIp.getIpAddress())) - .build()); + List portsInNeutronSubnet = neutronSubnet.getPortsInSubnet(); + if (portsInNeutronSubnet != null) { + for (NeutronPort port : portsInNeutronSubnet) { + if (NeutronPortAware.isRouterGatewayPort(port) || NeutronPortAware.isRouterInterfacePort(port)) { + continue; + } + boolean isPortAdded = NeutronPortAware.addNeutronPort(port, rwTx, epService); + if (!isPortAdded) { + return false; + } + // TODO Li msunal this has to be rewrite when OFOverlay renderer + // will support l3-endpoints. + Neutron_IPs firstIp = MappingUtils.getFirstIp(port.getFixedIPs()); + if (firstIp != null) { + l3Eps.add(new L3Builder().setL3Context(oldL3ContextId) + .setIpAddress(Utils.createIpAddress(firstIp.getIpAddress())) + .build()); + } } } if (neutronSubnet.getGatewayIP() != null) { @@ -359,28 +445,18 @@ public class NeutronRouterAware implements INeutronRouterAware { return true; } - @Override - public int canDetachInterface(NeutronRouter router, NeutronRouter_Interface routerInterface) { + public static int canDetachInterface(NeutronRouter router, NeutronRouter_Interface routerInterface) { LOG.trace("canDetachInterface - router: {} interface: {}", router, routerInterface); // nothing to consider return StatusCode.OK; } - @Override - public void neutronRouterInterfaceDetached(NeutronRouter router, NeutronRouter_Interface routerInterface) { + public static void neutronRouterInterfaceDetached(NeutronRouter router, NeutronRouter_Interface routerInterface, DataBroker dataProvider, EndpointService epService) { LOG.trace("neutronRouterInterfaceDetached - router: {} interface: {}", router, routerInterface); - NeutronCRUDInterfaces neutronCRUDInterface = new NeutronCRUDInterfaces().fetchINeutronSubnetCRUD(this); - INeutronSubnetCRUD subnetInterface = neutronCRUDInterface.getSubnetInterface(); - if (subnetInterface == null) { - LOG.warn("Illegal state - No provider for {}", INeutronSubnetCRUD.class.getName()); - return; - } - ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction(); TenantId tenantId = new TenantId(Utils.normalizeUuid(router.getTenantID())); L3ContextId l3ContextId = new L3ContextId(router.getID()); SubnetId subnetId = new SubnetId(routerInterface.getSubnetUUID()); - InstanceIdentifier l3ContextIid = IidFactory.l3ContextIid(tenantId, l3ContextId); DataStoreHelper.removeIfExists(LogicalDatastoreType.CONFIGURATION, IidFactory.l3ContextIid(tenantId, l3ContextId), rwTx); @@ -415,8 +491,14 @@ public class NeutronRouterAware implements INeutronRouterAware { potentialNetworkMapping.get().getL3ContextId()).build(); rwTx.put(LogicalDatastoreType.CONFIGURATION, IidFactory.l2BridgeDomainIid(tenantId, l2BridgeDomain.getId()), l2BridgeDomain); - - NeutronSubnet neutronSubnet = subnetInterface.getSubnet(subnetId.getValue()); + NeutronSubnet neutronSubnet = new NeutronSubnet(); + Subnets subnets = NeutronListener.getNeutronDataAfter().getSubnets(); + for (org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet s : subnets.getSubnet()) { + if (s.getUuid().getValue().equals(subnet.getId().getValue())) { + neutronSubnet = NeutronSubnetAware.toNeutron(s); + break; + } + } List portsInNeutronSubnet = neutronSubnet.getPortsInSubnet(); for (NeutronPort port : portsInNeutronSubnet) { if (NeutronPortAware.isRouterGatewayPort(port) || NeutronPortAware.isRouterInterfacePort(port)) { @@ -429,5 +511,4 @@ public class NeutronRouterAware implements INeutronRouterAware { } } } - } diff --git a/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/NeutronSubnetAware.java b/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/NeutronSubnetAware.java index 9f847f951..750f3624a 100644 --- a/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/NeutronSubnetAware.java +++ b/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/NeutronSubnetAware.java @@ -9,6 +9,9 @@ package org.opendaylight.groupbasedpolicy.neutron.mapper.mapping; import static com.google.common.base.Preconditions.checkNotNull; +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.ReadWriteTransaction; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; @@ -17,8 +20,9 @@ import org.opendaylight.groupbasedpolicy.neutron.mapper.util.MappingUtils.Forwar import org.opendaylight.groupbasedpolicy.neutron.mapper.util.Utils; import org.opendaylight.groupbasedpolicy.util.DataStoreHelper; import org.opendaylight.groupbasedpolicy.util.IidFactory; -import org.opendaylight.neutron.spi.INeutronSubnetAware; import org.opendaylight.neutron.spi.NeutronSubnet; +import org.opendaylight.neutron.spi.NeutronSubnetIPAllocationPool; +import org.opendaylight.neutron.spi.NeutronSubnet_HostRoute; import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ContextId; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.L2FloodDomainId; @@ -28,13 +32,24 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev 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.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.neutron.constants.rev150712.Dhcpv6Base; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.Dhcpv6Off; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.Dhcpv6Slaac; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.Dhcpv6Stateful; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.Dhcpv6Stateless; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.IpVersionBase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.IpVersionV4; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.IpVersionV6; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnet.attributes.AllocationPools; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnet.attributes.HostRoutes; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.google.common.base.Optional; import com.google.common.base.Strings; +import com.google.common.collect.ImmutableBiMap; -public class NeutronSubnetAware implements INeutronSubnetAware { +public class NeutronSubnetAware implements MappingProcessor { private final static Logger LOG = LoggerFactory.getLogger(NeutronSubnetAware.class); private final DataBroker dataProvider; @@ -45,22 +60,88 @@ public class NeutronSubnetAware implements INeutronSubnetAware { this.networkDao = checkNotNull(networkDao); } - /** - * @see org.opendaylight.neutron.spi.INeutronSubnetAware#canCreateSubnet(org.opendaylight.neutron.spi.NeutronSubnet) - */ + // copied from Neutron's NeutronSubnetInterface + static final ImmutableBiMap,Integer> IPV_MAP + = new ImmutableBiMap.Builder,Integer>() + .put(IpVersionV4.class, 4) + .put(IpVersionV6.class, 6) + .build(); + + // copied from Neutron's NeutronSubnetInterface + private static final ImmutableBiMap,String> DHCPV6_MAP + = new ImmutableBiMap.Builder,String>() + .put(Dhcpv6Off.class,"off") + .put(Dhcpv6Stateful.class,"dhcpv6-stateful") + .put(Dhcpv6Slaac.class,"slaac") + .put(Dhcpv6Stateless.class,"dhcpv6-stateless") + .build(); + + @Override + public NeutronSubnet convertToNeutron( + org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet subnet) { + return toNeutron(subnet); + } + + @SuppressWarnings("deprecation") + static NeutronSubnet toNeutron( + org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet subnet) { + NeutronSubnet result = new NeutronSubnet(); + result.setName(subnet.getName()); + result.setTenantID(subnet.getTenantId()); + result.setNetworkUUID(subnet.getNetworkId().getValue()); + result.setIpVersion(IPV_MAP.get(subnet.getIpVersion())); + result.setCidr(subnet.getCidr()); + if (subnet.getGatewayIp() != null) { + result.setGatewayIP(String.valueOf(subnet.getGatewayIp().getValue())); + } + if (subnet.getIpv6RaMode() != null) { + result.setIpV6RaMode(DHCPV6_MAP.get(subnet.getIpv6RaMode())); + } + if (subnet.getIpv6AddressMode() != null) { + result.setIpV6AddressMode(DHCPV6_MAP.get(subnet.getIpv6AddressMode())); + } + result.setEnableDHCP(subnet.isEnableDhcp()); + if (subnet.getAllocationPools() != null) { + List allocationPools = new ArrayList(); + for (AllocationPools allocationPool : subnet.getAllocationPools()) { + NeutronSubnetIPAllocationPool pool = new NeutronSubnetIPAllocationPool(); + pool.setPoolStart(allocationPool.getStart()); + pool.setPoolEnd(allocationPool.getEnd()); + allocationPools.add(pool); + } + result.setAllocationPools(allocationPools); + } + if (subnet.getDnsNameservers() != null) { + List dnsNameServers = new ArrayList(); + for (IpAddress dnsNameServer : subnet.getDnsNameservers()) { + dnsNameServers.add(String.valueOf(dnsNameServer.getValue())); + } + result.setDnsNameservers(dnsNameServers); + } + if (subnet.getHostRoutes() != null) { + List hostRoutes = new ArrayList(); + for (HostRoutes hostRoute : subnet.getHostRoutes()) { + NeutronSubnet_HostRoute nsHostRoute = new NeutronSubnet_HostRoute(); + nsHostRoute.setDestination(String.valueOf(hostRoute.getDestination().getValue())); + nsHostRoute.setNextHop(String.valueOf(hostRoute.getNexthop().getValue())); + hostRoutes.add(nsHostRoute); + } + result.setHostRoutes(hostRoutes); + } + result.setID(subnet.getUuid().getValue()); + return result; + } + @Override - public int canCreateSubnet(NeutronSubnet subnet) { - LOG.trace("canCreateSubnet - {}", subnet); + public int canCreate(NeutronSubnet subnet) { + LOG.trace("canCreate subnet - {}", subnet); // nothing to consider return StatusCode.OK; } - /** - * @see org.opendaylight.neutron.spi.INeutronSubnetAware#neutronSubnetCreated(org.opendaylight.neutron.spi.NeutronSubnet) - */ @Override - public void neutronSubnetCreated(NeutronSubnet neutronSubnet) { - LOG.trace("neutronSubnetCreated - {}", neutronSubnet); + public void created(NeutronSubnet neutronSubnet) { + LOG.trace("created subnet - {}", neutronSubnet); ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction(); SubnetId subnetId = new SubnetId(Utils.normalizeUuid(neutronSubnet.getID())); TenantId tenantId = new TenantId(Utils.normalizeUuid(neutronSubnet.getTenantID())); @@ -70,7 +151,7 @@ public class NeutronSubnetAware implements INeutronSubnetAware { rwTx = dataProvider.newReadWriteTransaction(); if (networkDao.isExternalNetwork(neutronSubnet.getNetworkUUID())) { - LOG.trace("neutronSubnetCreated - adding L3 Endpoint"); + LOG.trace("created - adding L3 Endpoint"); L2FloodDomainId l2FdId = new L2FloodDomainId(subnet.getParent().getValue()); ForwardingCtx fwCtx = MappingUtils.createForwardingContext(tenantId, l2FdId, rwTx); IpAddress defaultGateway = Utils.createIpAddress(neutronSubnet.getGatewayIP()); @@ -92,42 +173,29 @@ public class NeutronSubnetAware implements INeutronSubnetAware { return subnetBuilder.build(); } - /** - * @see org.opendaylight.neutron.spi.INeutronSubnetAware#canUpdateSubnet(org.opendaylight.neutron.spi.NeutronSubnet, - * org.opendaylight.neutron.spi.NeutronSubnet) - */ @Override - public int canUpdateSubnet(NeutronSubnet delta, NeutronSubnet original) { - LOG.trace("canUpdateSubnet - delta: {} original: {}", delta, original); + public int canUpdate(NeutronSubnet delta, NeutronSubnet original) { + LOG.trace("canUpdate subnet - delta: {} original: {}", delta, original); // nothing to consider return StatusCode.OK; } - /** - * @see org.opendaylight.neutron.spi.INeutronSubnetAware#neutronSubnetUpdated(org.opendaylight.neutron.spi.NeutronSubnet) - */ @Override - public void neutronSubnetUpdated(NeutronSubnet subnet) { - LOG.trace("neutronSubnetUpdated - {}", subnet); - neutronSubnetCreated(subnet); + public void updated(NeutronSubnet subnet) { + LOG.trace("updated subnet - {}", subnet); + created(subnet); } - /** - * @see org.opendaylight.neutron.spi.INeutronSubnetAware#canDeleteSubnet(org.opendaylight.neutron.spi.NeutronSubnet) - */ @Override - public int canDeleteSubnet(NeutronSubnet subnet) { - LOG.trace("canDeleteSubnet - {}", subnet); + public int canDelete(NeutronSubnet subnet) { + LOG.trace("canDelete subnet - {}", subnet); // nothing to consider return StatusCode.OK; } - /** - * @see org.opendaylight.neutron.spi.INeutronSubnetAware#neutronSubnetDeleted(org.opendaylight.neutron.spi.NeutronSubnet) - */ @Override - public void neutronSubnetDeleted(NeutronSubnet neutronSubnet) { - LOG.trace("neutronSubnetDeleted - {}", neutronSubnet); + public void deleted(NeutronSubnet neutronSubnet) { + LOG.trace("deleted subnet - {}", neutronSubnet); ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction(); SubnetId subnetId = new SubnetId(Utils.normalizeUuid(neutronSubnet.getID())); TenantId tenantId = new TenantId(Utils.normalizeUuid(neutronSubnet.getTenantID())); diff --git a/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/group/NeutronSecurityGroupAware.java b/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/group/NeutronSecurityGroupAware.java index 02e03cb44..4214eb427 100644 --- a/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/group/NeutronSecurityGroupAware.java +++ b/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/group/NeutronSecurityGroupAware.java @@ -15,16 +15,17 @@ import java.util.List; 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.neutron.mapper.mapping.MappingProcessor; import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.StatusCode; import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.rule.NeutronSecurityRuleAware; import org.opendaylight.groupbasedpolicy.neutron.mapper.util.MappingUtils; import org.opendaylight.groupbasedpolicy.neutron.mapper.util.Utils; import org.opendaylight.groupbasedpolicy.util.DataStoreHelper; import org.opendaylight.groupbasedpolicy.util.IidFactory; -import org.opendaylight.neutron.spi.INeutronSecurityGroupAware; import org.opendaylight.neutron.spi.NeutronSecurityGroup; import org.opendaylight.neutron.spi.NeutronSecurityRule; 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.rev130715.Uuid; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Description; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.EndpointGroupId; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.Name; @@ -32,10 +33,12 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev 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.EndpointGroup.IntraGroupPolicy; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.EndpointGroupBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.secgroups.rev150712.security.groups.attributes.security.groups.SecurityGroup; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import com.google.common.base.Function; import com.google.common.base.Optional; import com.google.common.base.Preconditions; import com.google.common.base.Strings; @@ -43,8 +46,9 @@ import com.google.common.collect.ArrayListMultimap; import com.google.common.collect.ImmutableList; import com.google.common.collect.ImmutableListMultimap; import com.google.common.collect.ListMultimap; +import com.google.common.collect.Lists; -public class NeutronSecurityGroupAware implements INeutronSecurityGroupAware { +public class NeutronSecurityGroupAware implements MappingProcessor { private static final Logger LOG = LoggerFactory.getLogger(NeutronSecurityGroupAware.class); private final DataBroker dataProvider; @@ -58,22 +62,43 @@ public class NeutronSecurityGroupAware implements INeutronSecurityGroupAware { this.secGroupDao = checkNotNull(secGroupDao); } - /** - * @see org.opendaylight.neutron.spi.INeutronSecurityGroupAware#canCreateNeutronSecurityGroup(org.opendaylight.neutron.spi.NeutronSecurityGroup) - */ @Override - public int canCreateNeutronSecurityGroup(NeutronSecurityGroup securityGroup) { - LOG.trace("canCreateNeutronSecurityGroup - {}", securityGroup); + public NeutronSecurityGroup convertToNeutron(SecurityGroup secGroup) { + NeutronSecurityGroup neutronSecGroup = new NeutronSecurityGroup(); + if (secGroup.getUuid() != null) { + neutronSecGroup.setID(secGroup.getUuid().getValue()); + } + if (secGroup.getName() != null) { + neutronSecGroup.setSecurityGroupName(secGroup.getName()); + } + if (secGroup.getTenantId() != null) { + neutronSecGroup.setTenantID(secGroup.getTenantId()); + } + if (secGroup.getSecurityRules() != null) { + neutronSecGroup.setSecurityRules(Lists.transform(secGroup.getSecurityRules(), + new Function() { + + @Override + public NeutronSecurityRule apply(Uuid uuid) { + NeutronSecurityRule rule = new NeutronSecurityRule(); + rule.setID(uuid.getValue()); + return rule; + } + })); + } + return neutronSecGroup; + } + + @Override + public int canCreate(NeutronSecurityGroup securityGroup) { + LOG.trace("canCreate securityGroup - {}", securityGroup); // nothing to consider return StatusCode.OK; } - /** - * @see org.opendaylight.neutron.spi.INeutronSecurityGroupAware#neutronSecurityGroupCreated(org.opendaylight.neutron.spi.NeutronSecurityGroup) - */ @Override - public void neutronSecurityGroupCreated(NeutronSecurityGroup secGroup) { - LOG.trace("neutronSecurityGroupCreated - {}", secGroup); + public void created(NeutronSecurityGroup secGroup) { + LOG.trace("created securityGroup - {}", secGroup); ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction(); boolean isSecGroupCreated = addNeutronSecurityGroup(secGroup, rwTx); if (isSecGroupCreated) { @@ -158,43 +183,30 @@ public class NeutronSecurityGroupAware implements INeutronSecurityGroupAware { return true; } - /** - * @see org.opendaylight.neutron.spi.INeutronSecurityGroupAware#canUpdateNeutronSecurityGroup(org.opendaylight.neutron.spi.NeutronSecurityGroup, - * org.opendaylight.neutron.spi.NeutronSecurityGroup) - */ @Override - public int canUpdateNeutronSecurityGroup(NeutronSecurityGroup delta, NeutronSecurityGroup original) { - LOG.warn("canUpdateNeutronSecurityGroup - Never should be called " + public int canUpdate(NeutronSecurityGroup delta, NeutronSecurityGroup original) { + LOG.warn("canUpdate securityGroup - Never should be called " + "- neutron API does not allow UPDATE on neutron security group. \nDelta: {} \nOriginal: {}", delta, original); return StatusCode.BAD_REQUEST; } - /** - * @see org.opendaylight.neutron.spi.INeutronSecurityGroupAware#neutronSecurityGroupUpdated(org.opendaylight.neutron.spi.NeutronSecurityGroup) - */ @Override - public void neutronSecurityGroupUpdated(NeutronSecurityGroup securityGroup) { - LOG.warn("neutronSecurityGroupUpdated - Never should be called " + public void updated(NeutronSecurityGroup securityGroup) { + LOG.warn("updated securityGroup - Never should be called " + "- neutron API does not allow UPDATE on neutron security group. \nSecurity group: {}", securityGroup); } - /** - * @see org.opendaylight.neutron.spi.INeutronSecurityGroupAware#canDeleteNeutronSecurityGroup(org.opendaylight.neutron.spi.NeutronSecurityGroup) - */ @Override - public int canDeleteNeutronSecurityGroup(NeutronSecurityGroup securityGroup) { - LOG.trace("canDeleteNeutronSecurityGroup - {}", securityGroup); + public int canDelete(NeutronSecurityGroup securityGroup) { + LOG.trace("canDelete securityGroup - {}", securityGroup); // nothing to consider return StatusCode.OK; } - /** - * @see org.opendaylight.neutron.spi.INeutronSecurityGroupAware#neutronSecurityGroupDeleted(org.opendaylight.neutron.spi.NeutronSecurityGroup) - */ @Override - public void neutronSecurityGroupDeleted(NeutronSecurityGroup secGroup) { - LOG.trace("neutronSecurityGroupDeleted - {}", secGroup); + public void deleted(NeutronSecurityGroup secGroup) { + LOG.trace("deleted securityGroup - {}", secGroup); ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction(); List secRules = secGroup.getSecurityRules(); if (secRules != null) { diff --git a/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/rule/NeutronSecurityRuleAware.java b/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/rule/NeutronSecurityRuleAware.java index 4e7201480..867e8b542 100644 --- a/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/rule/NeutronSecurityRuleAware.java +++ b/neutron-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/rule/NeutronSecurityRuleAware.java @@ -18,12 +18,12 @@ import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.groupbasedpolicy.api.sf.ChainActionDefinition; import org.opendaylight.groupbasedpolicy.dto.EgKey; +import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.MappingProcessor; import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.StatusCode; import org.opendaylight.groupbasedpolicy.neutron.mapper.mapping.group.SecGroupDao; import org.opendaylight.groupbasedpolicy.neutron.mapper.util.MappingUtils; import org.opendaylight.groupbasedpolicy.util.DataStoreHelper; import org.opendaylight.groupbasedpolicy.util.IidFactory; -import org.opendaylight.neutron.spi.INeutronSecurityRuleAware; import org.opendaylight.neutron.spi.NeutronSecurityRule; 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.groupbasedpolicy.common.rev140421.ActionName; @@ -46,6 +46,18 @@ import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev 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.policy.rev140421.tenants.tenant.policy.subject.feature.instances.ActionInstanceBuilder; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.policy.rev140421.tenants.tenant.policy.subject.feature.instances.ClassifierInstance; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.DirectionBase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.DirectionEgress; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.DirectionIngress; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.EthertypeBase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.EthertypeV4; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.EthertypeV6; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolBase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolIcmp; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolIcmpV6; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolTcp; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.constants.rev150712.ProtocolUdp; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.secgroups.rev150712.security.rules.attributes.security.rules.SecurityRule; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -53,11 +65,12 @@ import org.slf4j.LoggerFactory; import com.google.common.annotations.VisibleForTesting; import com.google.common.base.Strings; import com.google.common.collect.HashMultiset; +import com.google.common.collect.ImmutableBiMap; import com.google.common.collect.ImmutableList; import com.google.common.collect.Multiset; import com.google.common.collect.Sets; -public class NeutronSecurityRuleAware implements INeutronSecurityRuleAware { +public class NeutronSecurityRuleAware implements MappingProcessor { private static final Logger LOG = LoggerFactory.getLogger(NeutronSecurityRuleAware.class); private static final String CONTRACT_PROVIDER = "Contract provider: "; @@ -85,16 +98,76 @@ public class NeutronSecurityRuleAware implements INeutronSecurityRuleAware { this.createdActionInstances = checkNotNull(createdActionInstances); } + // copied from Neutron's NeutronSecurityRuleInterface + private static final ImmutableBiMap,String> DIRECTION_MAP + = new ImmutableBiMap.Builder,String>() + .put(DirectionEgress.class,"egress") + .put(DirectionIngress.class,"ingress") + .build(); + + // copied from Neutron's NeutronSecurityRuleInterface + private static final ImmutableBiMap,String> ETHERTYPE_MAP + = new ImmutableBiMap.Builder,String>() + .put(EthertypeV4.class,"IPv4") + .put(EthertypeV6.class,"IPv6") + .build(); + + // copied from Neutron's NeutronSecurityRuleInterface + private static final ImmutableBiMap,String> PROTOCOL_MAP + = new ImmutableBiMap.Builder,String>() + .put(ProtocolIcmp.class,"icmp") + .put(ProtocolTcp.class,"tcp") + .put(ProtocolUdp.class,"udp") + .put(ProtocolIcmpV6.class,"icmpv6") + .build(); + @Override - public int canCreateNeutronSecurityRule(NeutronSecurityRule securityRule) { - LOG.trace("canCreateNeutronSecurityRule - {}", securityRule); + public NeutronSecurityRule convertToNeutron(SecurityRule rule) { + // copied from Neutron's NeutronSecurityRuleInterface + NeutronSecurityRule answer = new NeutronSecurityRule(); + if (rule.getTenantId() != null) { + answer.setTenantID(rule.getTenantId()); + } + if (rule.getDirection() != null) { + answer.setSecurityRuleDirection(DIRECTION_MAP.get(rule.getDirection())); + } + if (rule.getSecurityGroupId() != null) { + answer.setSecurityRuleGroupID(rule.getSecurityGroupId().getValue()); + } + if (rule.getRemoteGroupId() != null) { + answer.setSecurityRemoteGroupID(rule.getRemoteGroupId().getValue()); + } + if (rule.getRemoteIpPrefix() != null) { + answer.setSecurityRuleRemoteIpPrefix(new String(rule.getRemoteIpPrefix().getValue())); + } + if (rule.getProtocol() != null) { + answer.setSecurityRuleProtocol(PROTOCOL_MAP.get(rule.getProtocol())); + } + if (rule.getEthertype() != null) { + answer.setSecurityRuleEthertype(ETHERTYPE_MAP.get(rule.getEthertype())); + } + if (rule.getPortRangeMin() != null) { + answer.setSecurityRulePortMin(rule.getPortRangeMin()); + } + if (rule.getPortRangeMax() != null) { + answer.setSecurityRulePortMax(rule.getPortRangeMax()); + } + if (rule.getId() != null) { + answer.setID(rule.getId().getValue()); + } + return answer; + } + + @Override + public int canCreate(NeutronSecurityRule securityRule) { + LOG.trace("canCreate securityRule - {}", securityRule); // nothing to consider return StatusCode.OK; } @Override - public void neutronSecurityRuleCreated(NeutronSecurityRule securityRule) { - LOG.trace("neutronSecurityRuleCreated - {}", securityRule); + public void created(NeutronSecurityRule securityRule) { + LOG.trace("created securityRule - {}", securityRule); ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction(); boolean isNeutronSecurityRuleAdded = addNeutronSecurityRule(securityRule, rwTx); if (isNeutronSecurityRuleAdded) { @@ -249,30 +322,30 @@ public class NeutronSecurityRuleAware implements INeutronSecurityRuleAware { } @Override - public int canUpdateNeutronSecurityRule(NeutronSecurityRule delta, NeutronSecurityRule original) { - LOG.warn("canUpdateNeutronSecurityRule - Never should be called " + public int canUpdate(NeutronSecurityRule delta, NeutronSecurityRule original) { + LOG.warn("canUpdate securityRule - Never should be called " + "- neutron API does not allow UPDATE on neutron security group rule. \nDelta: {} \nOriginal: {}", delta, original); return StatusCode.BAD_REQUEST; } @Override - public void neutronSecurityRuleUpdated(NeutronSecurityRule securityRule) { - LOG.warn("neutronSecurityRuleUpdated - Never should be called " + public void updated(NeutronSecurityRule securityRule) { + LOG.warn("updated securityRule - Never should be called " + "- neutron API does not allow UPDATE on neutron security group rule. \nSecurity group rule: {}", securityRule); } @Override - public int canDeleteNeutronSecurityRule(NeutronSecurityRule securityRule) { - LOG.trace("canDeleteNeutronSecurityRule - {}", securityRule); + public int canDelete(NeutronSecurityRule securityRule) { + LOG.trace("canDelete - securityRule - {}", securityRule); // nothing to consider return StatusCode.OK; } @Override - public void neutronSecurityRuleDeleted(NeutronSecurityRule secRule) { - LOG.trace("neutronSecurityRuleCreated - {}", secRule); + public void deleted(NeutronSecurityRule secRule) { + LOG.trace("deleted securityRule - {}", secRule); ReadWriteTransaction rwTx = dataProvider.newReadWriteTransaction(); boolean isNeutronSecurityRuleDeleted = deleteNeutronSecurityRule(secRule, rwTx); if (isNeutronSecurityRuleDeleted) { @@ -429,5 +502,4 @@ public class NeutronSecurityRuleAware implements INeutronSecurityRuleAware { return (Strings.isNullOrEmpty(two.getSecurityRemoteGroupID()) || two.getSecurityRemoteGroupID().equals( one.getSecurityRuleGroupID())); } - } diff --git a/neutron-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/group/NeutronSecurityGroupAwareDataStoreTest.java b/neutron-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/group/NeutronSecurityGroupAwareDataStoreTest.java index f9d1c7eb5..98d231b32 100644 --- a/neutron-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/group/NeutronSecurityGroupAwareDataStoreTest.java +++ b/neutron-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/group/NeutronSecurityGroupAwareDataStoreTest.java @@ -40,7 +40,7 @@ public class NeutronSecurityGroupAwareDataStoreTest extends GbpDataBrokerTest { NeutronSecurityGroup secGroup1 = NeutronEntityFactory.securityGroup(secGroupId1, tenantId); NeutronSecurityGroup secGroup2 = NeutronEntityFactory.securityGroup(secGroupId2, tenantId); - groupAware.neutronSecurityGroupCreated(secGroup1); + groupAware.created(secGroup1); PolicyAssert.assertTenantExists(dataBroker, tenantId); PolicyAssert.assertContractCount(dataBroker, tenantId, 0); @@ -50,14 +50,14 @@ public class NeutronSecurityGroupAwareDataStoreTest extends GbpDataBrokerTest { PolicyAssert.assertNoConsumerNamedSelectors(dataBroker, tenantId, secGroupId1); PolicyAssert.assertIntraGroupPolicy(dataBroker, tenantId, secGroupId1, IntraGroupPolicy.RequireContract); - groupAware.neutronSecurityGroupDeleted(secGroup1); + groupAware.deleted(secGroup1); PolicyAssert.assertTenantExists(dataBroker, tenantId); PolicyAssert.assertContractCount(dataBroker, tenantId, 0); PolicyAssert.assertEndpointGroupCount(dataBroker, tenantId, 0); - groupAware.neutronSecurityGroupCreated(secGroup1); - groupAware.neutronSecurityGroupCreated(secGroup2); + groupAware.created(secGroup1); + groupAware.created(secGroup2); PolicyAssert.assertTenantExists(dataBroker, tenantId); PolicyAssert.assertContractCount(dataBroker, tenantId, 0); @@ -71,7 +71,7 @@ public class NeutronSecurityGroupAwareDataStoreTest extends GbpDataBrokerTest { PolicyAssert.assertNoConsumerNamedSelectors(dataBroker, tenantId, secGroupId2); PolicyAssert.assertIntraGroupPolicy(dataBroker, tenantId, secGroupId2, IntraGroupPolicy.RequireContract); - groupAware.neutronSecurityGroupDeleted(secGroup2); + groupAware.deleted(secGroup2); PolicyAssert.assertTenantExists(dataBroker, tenantId); PolicyAssert.assertContractCount(dataBroker, tenantId, 0); @@ -80,7 +80,7 @@ public class NeutronSecurityGroupAwareDataStoreTest extends GbpDataBrokerTest { PolicyAssert.assertNoProviderNamedSelectors(dataBroker, tenantId, secGroupId1); PolicyAssert.assertNoConsumerNamedSelectors(dataBroker, tenantId, secGroupId1); - groupAware.neutronSecurityGroupDeleted(secGroup1); + groupAware.deleted(secGroup1); PolicyAssert.assertTenantExists(dataBroker, tenantId); PolicyAssert.assertContractCount(dataBroker, tenantId, 0); @@ -113,7 +113,7 @@ public class NeutronSecurityGroupAwareDataStoreTest extends GbpDataBrokerTest { NeutronSecurityGroup secGroup2 = NeutronEntityFactory.securityGroup(secGroupId2, tenantId, ImmutableList.of(secRule2)); - groupAware.neutronSecurityGroupCreated(secGroup1); + groupAware.created(secGroup1); PolicyAssert.assertTenantExists(dataBroker, tenantId); PolicyAssert.assertContractExists(dataBroker, tenantId, secRuleId1); @@ -130,7 +130,7 @@ public class NeutronSecurityGroupAwareDataStoreTest extends GbpDataBrokerTest { PolicyAssert.assertClassifierInstanceExists(dataBroker, secRule1); PolicyAssert.assertActionInstanceExists(dataBroker, tenantId, MappingUtils.ACTION_ALLOW.getName()); - groupAware.neutronSecurityGroupDeleted(secGroup1); + groupAware.deleted(secGroup1); PolicyAssert.assertTenantExists(dataBroker, tenantId); PolicyAssert.assertContractCount(dataBroker, tenantId, 0); @@ -140,8 +140,8 @@ public class NeutronSecurityGroupAwareDataStoreTest extends GbpDataBrokerTest { // TODO: Uncomment this when the life cycle of the Allow ActionInstance will be clarified. // PolicyAssert.assertActionInstanceNotExists(dataBroker, tenantId, MappingUtils.ACTION_ALLOW.getName()); - groupAware.neutronSecurityGroupCreated(secGroup1); - groupAware.neutronSecurityGroupCreated(secGroup2); + groupAware.created(secGroup1); + groupAware.created(secGroup2); PolicyAssert.assertTenantExists(dataBroker, tenantId); PolicyAssert.assertContractExists(dataBroker, tenantId, secRuleId1); @@ -164,7 +164,7 @@ public class NeutronSecurityGroupAwareDataStoreTest extends GbpDataBrokerTest { PolicyAssert.assertClassifierInstanceExists(dataBroker, secRule1); PolicyAssert.assertActionInstanceExists(dataBroker, tenantId, MappingUtils.ACTION_ALLOW.getName()); - groupAware.neutronSecurityGroupDeleted(secGroup2); + groupAware.deleted(secGroup2); PolicyAssert.assertTenantExists(dataBroker, tenantId); PolicyAssert.assertContractExists(dataBroker, tenantId, secRuleId1); @@ -181,7 +181,7 @@ public class NeutronSecurityGroupAwareDataStoreTest extends GbpDataBrokerTest { PolicyAssert.assertClassifierInstanceExists(dataBroker, secRule1); PolicyAssert.assertActionInstanceExists(dataBroker, tenantId, MappingUtils.ACTION_ALLOW.getName()); - groupAware.neutronSecurityGroupDeleted(secGroup1); + groupAware.deleted(secGroup1); PolicyAssert.assertTenantExists(dataBroker, tenantId); PolicyAssert.assertContractCount(dataBroker, tenantId, 0); diff --git a/neutron-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/rule/NeutronSecurityRuleAwareDataStoreTest.java b/neutron-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/rule/NeutronSecurityRuleAwareDataStoreTest.java index c16b79620..0d1545b2d 100644 --- a/neutron-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/rule/NeutronSecurityRuleAwareDataStoreTest.java +++ b/neutron-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/rule/NeutronSecurityRuleAwareDataStoreTest.java @@ -138,7 +138,7 @@ public class NeutronSecurityRuleAwareDataStoreTest extends GbpDataBrokerTest { NeutronSecurityRule secRule2 = NeutronEntityFactory.securityRuleWithEtherType(secRuleId2, tenantId, NeutronUtils.IPv4, NeutronUtils.INGRESS, secGroupId2, secGroupId1); - ruleAware.neutronSecurityRuleCreated(secRule1); + ruleAware.created(secRule1); PolicyAssert.assertTenantExists(dataBroker, tenantId); PolicyAssert.assertContractExists(dataBroker, tenantId, secRuleId1); @@ -153,7 +153,7 @@ public class NeutronSecurityRuleAwareDataStoreTest extends GbpDataBrokerTest { PolicyAssert.assertClassifierInstanceExists(dataBroker, secRule1); PolicyAssert.assertActionInstanceExists(dataBroker, tenantId, MappingUtils.ACTION_ALLOW.getName()); - ruleAware.neutronSecurityRuleCreated(secRule2); + ruleAware.created(secRule2); PolicyAssert.assertTenantExists(dataBroker, tenantId); PolicyAssert.assertContractExists(dataBroker, tenantId, secRuleId1); @@ -174,7 +174,7 @@ public class NeutronSecurityRuleAwareDataStoreTest extends GbpDataBrokerTest { PolicyAssert.assertProviderNamedSelectors(epGroup2.get(), ImmutableSet.of(new ContractId(secRuleId2))); PolicyAssert.assertConsumerNamedSelectors(epGroup2.get(), ImmutableSet.of(new ContractId(secRuleId1))); - ruleAware.neutronSecurityRuleDeleted(secRule2); + ruleAware.deleted(secRule2); PolicyAssert.assertTenantExists(dataBroker, tenantId); PolicyAssert.assertContractExists(dataBroker, tenantId, secRuleId1); @@ -196,7 +196,7 @@ public class NeutronSecurityRuleAwareDataStoreTest extends GbpDataBrokerTest { PolicyAssert.assertClassifierInstanceExists(dataBroker, secRule1); PolicyAssert.assertActionInstanceExists(dataBroker, tenantId, MappingUtils.ACTION_ALLOW.getName()); - ruleAware.neutronSecurityRuleDeleted(secRule1); + ruleAware.deleted(secRule1); PolicyAssert.assertContractCount(dataBroker, tenantId, 0); PolicyAssert.assertEndpointGroupExists(dataBroker, tenantId, secGroupId1); diff --git a/neutron-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/rule/NeutronSecurityRuleAwareTest.java b/neutron-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/rule/NeutronSecurityRuleAwareTest.java index 53c9560b3..5a82b60fc 100644 --- a/neutron-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/rule/NeutronSecurityRuleAwareTest.java +++ b/neutron-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/mapper/mapping/rule/NeutronSecurityRuleAwareTest.java @@ -52,9 +52,9 @@ public class NeutronSecurityRuleAwareTest extends GbpDataBrokerTest { //create security rule and put to DS NeutronSecurityRule neutronRule = buildNeutronSecurityRule(); - assertEquals(neutronSecurityRuleAware.canCreateNeutronSecurityRule(neutronRule), + assertEquals(neutronSecurityRuleAware.canCreate(neutronRule), StatusCode.OK); - neutronSecurityRuleAware.neutronSecurityRuleCreated(neutronRule); + neutronSecurityRuleAware.created(neutronRule); //read security rule PolicyAssert.assertContractExists(dataProvider, RULE_TENANT_ID, RULE_ID); @@ -64,13 +64,13 @@ public class NeutronSecurityRuleAwareTest extends GbpDataBrokerTest { assertNotNull(readContract); assertEquals(readContract.getId().getValue(), RULE_ID); - assertEquals(neutronSecurityRuleAware.canUpdateNeutronSecurityRule(neutronRule, neutronRule), + assertEquals(neutronSecurityRuleAware.canUpdate(neutronRule, neutronRule), StatusCode.BAD_REQUEST); //delete rule - assertEquals(neutronSecurityRuleAware.canDeleteNeutronSecurityRule(neutronRule), + assertEquals(neutronSecurityRuleAware.canDelete(neutronRule), StatusCode.OK); - neutronSecurityRuleAware.neutronSecurityRuleDeleted(neutronRule); + neutronSecurityRuleAware.deleted(neutronRule); PolicyAssert.assertContractNotExists(dataProvider, RULE_TENANT_ID, RULE_ID); }