<version>${neutron.version}</version>
<type>xml</type>
</dependency>
-
+ <dependency>
+ <groupId>org.opendaylight.neutron</groupId>
+ <artifactId>dummyprovider</artifactId>
+ <version>${neutron.version}</version>
+ </dependency>
+
<!-- Faas -->
<dependency>
<groupId>org.opendaylight.faas</groupId>
<feature version="${neutron.version}">odl-neutron-service</feature>
<feature version="${project.version}">odl-groupbasedpolicy-base</feature>
<feature version="${project.version}">odl-groupbasedpolicy-ofoverlay</feature>
+ <bundle>mvn:org.opendaylight.neutron/dummyprovider/{{VERSION}}</bundle>
<bundle>mvn:org.opendaylight.groupbasedpolicy/neutron-mapper/{{VERSION}}</bundle>
<bundle>mvn:org.opendaylight.groupbasedpolicy/neutron-ovsdb/{{VERSION}}</bundle>
<configfile finalname="${config.configfile.directory}/15-neutron-mapper.xml">mvn:org.opendaylight.groupbasedpolicy/neutron-mapper/{{VERSION}}/xml/config</configfile>
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);
@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() {
};
}
- public void setBundleContext(BundleContext bundleContext) {
- this.bundleContext = bundleContext;
- }
-
}
@Override
public Module createModule(String instanceName, DependencyResolver dependencyResolver, BundleContext bundleContext) {
NeutronMapperModule module = (NeutronMapperModule) super.createModule(instanceName, dependencyResolver, bundleContext);
- module.setBundleContext(bundleContext);
return module;
}
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;
}
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;
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 {
private final List<ServiceRegistration<?>> registrations = new ArrayList<ServiceRegistration<?>>();
private final DataBroker dataProvider;
private final RpcProviderRegistry providerRegistry;
- private final BundleContext context;
private final EndpointService epService;
private RpcRegistration<NeutronGbpMapperService> 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();
}
SecGroupDao secGroupDao = new SecGroupDao();
SecRuleDao secRuleDao = new SecRuleDao();
NeutronNetworkDao networkDao = new NeutronNetworkDao();
-
- ServiceRegistration<INeutronSubnetAware> neutronSubnetAwareRegistration =
- context.registerService(INeutronSubnetAware.class, new NeutronSubnetAware(dataProvider, networkDao), null);
- registrations.add(neutronSubnetAwareRegistration);
-
NeutronSecurityRuleAware securityRuleAware = new NeutronSecurityRuleAware(dataProvider, secRuleDao, secGroupDao);
- ServiceRegistration<INeutronSecurityRuleAware> neutronSecurityRuleAwareRegistration =
- context.registerService(INeutronSecurityRuleAware.class, securityRuleAware, null);
- registrations.add(neutronSecurityRuleAwareRegistration);
-
NeutronSecurityGroupAware securityGroupAware = new NeutronSecurityGroupAware(dataProvider, securityRuleAware, secGroupDao);
- ServiceRegistration<INeutronSecurityGroupAware> neutronSecurityGroupAwareRegistration =
- context.registerService(INeutronSecurityGroupAware.class, securityGroupAware, null);
- registrations.add(neutronSecurityGroupAwareRegistration);
-
- ServiceRegistration<INeutronNetworkAware> neutronNetworkAwareRegistration = context.registerService(
- INeutronNetworkAware.class, new NeutronNetworkAware(dataProvider, securityGroupAware, networkDao), null);
- registrations.add(neutronNetworkAwareRegistration);
-
- NeutronPortAware portAware =
- new NeutronPortAware(dataProvider, epService, securityRuleAware, securityGroupAware);
- ServiceRegistration<INeutronPortAware> neutronPortAwareRegistration =
- context.registerService(INeutronPortAware.class, portAware, null);
- registrations.add(neutronPortAwareRegistration);
-
- NeutronRouterAware routerAware = new NeutronRouterAware(dataProvider, epService);
- ServiceRegistration<INeutronRouterAware> neutronRouterAwareRegistration =
- context.registerService(INeutronRouterAware.class, routerAware, null);
- registrations.add(neutronRouterAwareRegistration);
-
- ServiceRegistration<INeutronFloatingIPAware> 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);
}
for (ServiceRegistration<?> registration : registrations) {
registration.unregister();
}
+ if (neutronListener != null) {
+ neutronListener.close();
+ neutronListener = null;
+ }
rpcRegistration.close();
}
--- /dev/null
+/*\r
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+package org.opendaylight.groupbasedpolicy.neutron.mapper.mapping;\r
+\r
+import org.opendaylight.neutron.spi.NeutronObject;\r
+import org.opendaylight.yangtools.yang.binding.DataObject;\r
+\r
+public interface MappingProcessor <D extends DataObject, T extends NeutronObject> {\r
+\r
+ int canCreate(T t);\r
+ int canUpdate(T original, T delta);\r
+ int canDelete(T t);\r
+\r
+ void updated(T t);\r
+ void created(T t);\r
+ void deleted(T t);\r
+\r
+ T convertToNeutron(D d);\r
+}\r
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<Floatingip, NeutronFloatingIP> {
public static final Logger LOG = LoggerFactory.getLogger(NeutronFloatingIpAware.class);
private final DataBroker dataProvider;
}
@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)) {
}
@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);
}
-
}
--- /dev/null
+/*\r
+ * Copyright (c) 2015 Cisco Systems, Inc. and others. All rights reserved.\r
+ *\r
+ * This program and the accompanying materials are made available under the\r
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
+ * and is available at http://www.eclipse.org/legal/epl-v10.html\r
+ */\r
+package org.opendaylight.groupbasedpolicy.neutron.mapper.mapping;\r
+\r
+import java.io.Closeable;\r
+import java.io.IOException;\r
+import java.util.ArrayList;\r
+import java.util.Collection;\r
+import java.util.LinkedHashMap;\r
+import java.util.List;\r
+import java.util.Map;\r
+\r
+import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;\r
+import org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeChangeListener;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;\r
+import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;\r
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
+import org.opendaylight.neutron.spi.NeutronObject;\r
+import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron;\r
+import org.opendaylight.yangtools.concepts.ListenerRegistration;\r
+import org.opendaylight.yangtools.yang.binding.DataObject;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;\r
+\r
+import com.google.common.collect.Iterators;\r
+import com.google.common.collect.PeekingIterator;\r
+\r
+public class NeutronListener implements DataTreeChangeListener<Neutron>, Closeable {\r
+\r
+ private final ListenerRegistration<NeutronListener> registerDataTreeChangeListener;\r
+ private final Map<InstanceIdentifier<? extends DataObject>, MappingProcessor<? extends DataObject, ? extends NeutronObject>> dataChangeProviders = new LinkedHashMap<>();\r
+ private static DataObjectModification<Neutron> neutron;\r
+\r
+ public NeutronListener(DataBroker dataProvider) {\r
+ registerDataTreeChangeListener = dataProvider.registerDataTreeChangeListener(new DataTreeIdentifier<>(\r
+ LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.builder(Neutron.class).build()), this);\r
+ }\r
+\r
+ @Override\r
+ public void onDataTreeChanged(Collection<DataTreeModification<Neutron>> changes) {\r
+ for (DataTreeModification<Neutron> change : changes) {\r
+ neutron = change.getRootNode();\r
+ for (InstanceIdentifier<? extends DataObject> iid : dataChangeProviders.keySet()) {\r
+ for (DataObjectModification<? extends DataObject> modifDto : findModifiedData(iid, change.getRootNode())) {\r
+ processChangedData(modifDto, modifDto.getModificationType(), getMappingProvider(iid));\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ /**\r
+ * Finds all modified subnodes of given type in {@link Neutron} node.\r
+ *\r
+ * @param iid path to data in root node\r
+ * @param rootNode modified data of {@link Neutron} node\r
+ * @return {@link List} of modified subnodes\r
+ */\r
+ private List<DataObjectModification<? extends DataObject>> findModifiedData(\r
+ InstanceIdentifier<? extends DataObject> iid, DataObjectModification<Neutron> rootNode) {\r
+ List<DataObjectModification<? extends DataObject>> modDtos = new ArrayList<>();\r
+ PeekingIterator<PathArgument> pathArgs = Iterators.peekingIterator(iid.getPathArguments().iterator());\r
+ DataObjectModification<? extends DataObject> modifDto = rootNode;\r
+ while (pathArgs.hasNext()) {\r
+ pathArgs.next();\r
+ for (DataObjectModification<? extends DataObject> childDto : modifDto.getModifiedChildren()) {\r
+ if (pathArgs.hasNext() && childDto.getDataType().equals(pathArgs.peek().getType())) {\r
+ if (childDto.getDataType().equals(iid.getTargetType())) {\r
+ modDtos.add(childDto);\r
+ } else {\r
+ modifDto = childDto;\r
+ break;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ return modDtos;\r
+ }\r
+\r
+ static Neutron getNeutronDataBefore() {\r
+ return neutron.getDataBefore();\r
+ }\r
+\r
+ static Neutron getNeutronDataAfter() {\r
+ return neutron.getDataAfter();\r
+ }\r
+\r
+ @SuppressWarnings("unchecked")\r
+ <T extends DataObject, X extends NeutronObject> void processChangedData(DataObjectModification<?> dto,\r
+ ModificationType m, MappingProcessor<T, X> d) {\r
+ switch (m) {\r
+ case WRITE: {\r
+ T dataAfter = (T) dto.getDataAfter();\r
+ X neutronObject = d.convertToNeutron(dataAfter);\r
+ if (StatusCode.OK == d.canCreate(neutronObject)) {\r
+ d.created(neutronObject);\r
+ }\r
+ break;\r
+ }\r
+ case SUBTREE_MODIFIED: {\r
+ X neutronObjectBefore = d.convertToNeutron((T) dto.getDataBefore());\r
+ X neutronObjectAfter = d.convertToNeutron((T) dto.getDataAfter());\r
+ if (StatusCode.OK == d.canUpdate(neutronObjectAfter, neutronObjectBefore)) {\r
+ d.updated(neutronObjectAfter);\r
+ }\r
+ break;\r
+ }\r
+ case DELETE: {\r
+ X neutronObjectBefore = d.convertToNeutron((T) dto.getDataBefore());\r
+ if (StatusCode.OK == d.canDelete(neutronObjectBefore)) {\r
+ d.deleted(neutronObjectBefore);\r
+ }\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+ public <D extends DataObject, N extends NeutronObject> void registerMappingProviders(\r
+ InstanceIdentifier<D> iid, MappingProcessor<D, N> np) {\r
+ dataChangeProviders.put(iid, np);\r
+ }\r
+\r
+ @SuppressWarnings("unchecked")\r
+ <D extends DataObject, N extends NeutronObject> MappingProcessor<D, N> getMappingProvider(\r
+ InstanceIdentifier<D> iid) {\r
+ return (MappingProcessor<D, N>) dataChangeProviders.get(iid);\r
+ }\r
+\r
+ @Override\r
+ public void close() throws IOException {\r
+ registerDataTreeChangeListener.close();\r
+ }\r
+\r
+}\r
+\r
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;
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;
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<Network, NeutronNetwork> {
private static final Logger LOG = LoggerFactory.getLogger(NeutronNetworkAware.class);
private final DataBroker dataProvider;
this.networkDao = checkNotNull(networkDao);
}
- /**
- * @see org.opendaylight.neutron.spi.INeutronNetworkAware#canCreateNetwork(org.opendaylight.neutron.spi.NeutronNetwork)
- */
+ private static final ImmutableBiMap<Class<? extends NetworkTypeBase>,String> NETWORK_MAP
+ = new ImmutableBiMap.Builder<Class<? extends NetworkTypeBase>,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<NeutronNetwork_Segment> segments = new ArrayList<NeutronNetwork_Segment>();
+ 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()));
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());
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;
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;
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<Port, NeutronPort> {
public static final Logger LOG = LoggerFactory.getLogger(NeutronPortAware.class);
private static final String DEVICE_OWNER_DHCP = "network:dhcp";
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<NeutronPort_AllowedAddressPairs> pairs = new ArrayList<NeutronPort_AllowedAddressPairs>();
+ 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<NeutronPort_ExtraDHCPOption> options = new ArrayList<NeutronPort_ExtraDHCPOption>();
+ 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<Neutron_IPs> ips = new ArrayList<Neutron_IPs>();
+ 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<Uuid, NeutronSecurityGroup>() {
+
+ @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<NeutronPort_VIFDetail> details = new ArrayList<NeutronPort_VIFDetail>();
+ 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<Neutron_IPs> 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());
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;
}
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());
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());
}
return l3s;
}
-
}
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;
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;
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;
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableList;
-public class NeutronRouterAware implements INeutronRouterAware {
+public class NeutronRouterAware implements MappingProcessor<Router, NeutronRouter> {
private static final Logger LOG = LoggerFactory.getLogger(NeutronRouterAware.class);
private static final String DEFAULT_ROUTE = "0.0.0.0/0";
}
@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<NeutronRoute> routes = new ArrayList<NeutronRoute>();
+ 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<Neutron_IPs> fixedIPs = new ArrayList<Neutron_IPs>();
+ 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<String, NeutronRouter_Interface> interfaces = new HashMap<String, NeutronRouter_Interface>();
+ 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;
routerPort.setTenantID(router.getTenantID());
}
- boolean isSuccessful = setNewL3ContextToEpsFromSubnet(tenantId, l3Context, subnet, rwTx);
+ boolean isSuccessful = setNewL3ContextToEpsFromSubnet(tenantId, l3Context, subnet, rwTx, epService);
if (!isSuccessful) {
rwTx.cancel();
return;
}
@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());
}
}
- @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());
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);
}
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;
.build();
}
- private @Nullable Subnet resolveSubnetWithVirtualRouterIp(TenantId tenantId, SubnetId subnetId,
+ private static @Nullable Subnet resolveSubnetWithVirtualRouterIp(TenantId tenantId, SubnetId subnetId,
IpAddress ipAddress, ReadTransaction rTx) {
Optional<Subnet> potentialSubnet = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,
IidFactory.subnetIid(tenantId, subnetId), rTx);
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;
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<L3> l3Eps = new ArrayList<>();
L3ContextId oldL3ContextId = fwCtx.getL3Context().getId();
- NeutronSubnet neutronSubnet = subnetInterface.getSubnet(subnet.getId().getValue());
- List<NeutronPort> 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<NeutronPort> 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) {
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<L3Context> l3ContextIid = IidFactory.l3ContextIid(tenantId, l3ContextId);
DataStoreHelper.removeIfExists(LogicalDatastoreType.CONFIGURATION,
IidFactory.l3ContextIid(tenantId, l3ContextId), rwTx);
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<NeutronPort> portsInNeutronSubnet = neutronSubnet.getPortsInSubnet();
for (NeutronPort port : portsInNeutronSubnet) {
if (NeutronPortAware.isRouterGatewayPort(port) || NeutronPortAware.isRouterInterfacePort(port)) {
}
}
}
-
}
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;
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;
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<org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.subnets.rev150712.subnets.attributes.subnets.Subnet, NeutronSubnet> {
private final static Logger LOG = LoggerFactory.getLogger(NeutronSubnetAware.class);
private final DataBroker dataProvider;
this.networkDao = checkNotNull(networkDao);
}
- /**
- * @see org.opendaylight.neutron.spi.INeutronSubnetAware#canCreateSubnet(org.opendaylight.neutron.spi.NeutronSubnet)
- */
+ // copied from Neutron's NeutronSubnetInterface
+ static final ImmutableBiMap<Class<? extends IpVersionBase>,Integer> IPV_MAP
+ = new ImmutableBiMap.Builder<Class<? extends IpVersionBase>,Integer>()
+ .put(IpVersionV4.class, 4)
+ .put(IpVersionV6.class, 6)
+ .build();
+
+ // copied from Neutron's NeutronSubnetInterface
+ private static final ImmutableBiMap<Class<? extends Dhcpv6Base>,String> DHCPV6_MAP
+ = new ImmutableBiMap.Builder<Class<? extends Dhcpv6Base>,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<NeutronSubnetIPAllocationPool> allocationPools = new ArrayList<NeutronSubnetIPAllocationPool>();
+ 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<String> dnsNameServers = new ArrayList<String>();
+ for (IpAddress dnsNameServer : subnet.getDnsNameservers()) {
+ dnsNameServers.add(String.valueOf(dnsNameServer.getValue()));
+ }
+ result.setDnsNameservers(dnsNameServers);
+ }
+ if (subnet.getHostRoutes() != null) {
+ List<NeutronSubnet_HostRoute> hostRoutes = new ArrayList<NeutronSubnet_HostRoute>();
+ 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()));
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());
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()));
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;
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;
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<SecurityGroup, NeutronSecurityGroup> {
private static final Logger LOG = LoggerFactory.getLogger(NeutronSecurityGroupAware.class);
private final DataBroker dataProvider;
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<Uuid, NeutronSecurityRule>() {
+
+ @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) {
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<NeutronSecurityRule> secRules = secGroup.getSecurityRules();
if (secRules != null) {
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;
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;
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<SecurityRule, NeutronSecurityRule> {
private static final Logger LOG = LoggerFactory.getLogger(NeutronSecurityRuleAware.class);
private static final String CONTRACT_PROVIDER = "Contract provider: ";
this.createdActionInstances = checkNotNull(createdActionInstances);
}
+ // copied from Neutron's NeutronSecurityRuleInterface
+ private static final ImmutableBiMap<Class<? extends DirectionBase>,String> DIRECTION_MAP
+ = new ImmutableBiMap.Builder<Class<? extends DirectionBase>,String>()
+ .put(DirectionEgress.class,"egress")
+ .put(DirectionIngress.class,"ingress")
+ .build();
+
+ // copied from Neutron's NeutronSecurityRuleInterface
+ private static final ImmutableBiMap<Class<? extends EthertypeBase>,String> ETHERTYPE_MAP
+ = new ImmutableBiMap.Builder<Class<? extends EthertypeBase>,String>()
+ .put(EthertypeV4.class,"IPv4")
+ .put(EthertypeV6.class,"IPv6")
+ .build();
+
+ // copied from Neutron's NeutronSecurityRuleInterface
+ private static final ImmutableBiMap<Class<? extends ProtocolBase>,String> PROTOCOL_MAP
+ = new ImmutableBiMap.Builder<Class<? extends ProtocolBase>,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) {
}
@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) {
return (Strings.isNullOrEmpty(two.getSecurityRemoteGroupID()) || two.getSecurityRemoteGroupID().equals(
one.getSecurityRuleGroupID()));
}
-
}
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);
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);
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);
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);
NeutronSecurityGroup secGroup2 = NeutronEntityFactory.securityGroup(secGroupId2, tenantId,
ImmutableList.of(secRule2));
- groupAware.neutronSecurityGroupCreated(secGroup1);
+ groupAware.created(secGroup1);
PolicyAssert.assertTenantExists(dataBroker, tenantId);
PolicyAssert.assertContractExists(dataBroker, tenantId, secRuleId1);
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);
// 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);
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);
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);
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);
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);
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);
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);
//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);
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);
}
Code Review / groupbasedpolicy.git / commitdiff