From: Tomas Cechvala Date: Wed, 25 May 2016 16:16:04 +0000 (+0200) Subject: Baseline for neutron-vpp mapping X-Git-Tag: release/boron~146 X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=commitdiff_plain;h=5ecba6505c69c40006f91023631a5078d97cc1f0;p=groupbasedpolicy.git Baseline for neutron-vpp mapping Initial implementation of neutron-vpp mapper Initial yang for vpp renderer Change-Id: Ief0fbc85e68f9c094c9c0ca6687c132cbd8ca6ea Signed-off-by: Tomas Cechvala --- diff --git a/artifacts/pom.xml b/artifacts/pom.xml index 93101c44a..c8d26b90b 100755 --- a/artifacts/pom.xml +++ b/artifacts/pom.xml @@ -66,6 +66,11 @@ neutron-mapper ${project.version} + + ${project.groupId} + neutron-vpp-mapper + ${project.version} + ${project.groupId} neutron-ovsdb @@ -156,6 +161,13 @@ xml config + + ${project.groupId} + neutron-vpp-mapper + ${project.version} + xml + config + ${project.groupId} neutron-ovsdb diff --git a/features/pom.xml b/features/pom.xml index fd2622780..72cc9ac63 100755 --- a/features/pom.xml +++ b/features/pom.xml @@ -274,6 +274,10 @@ org.opendaylight.groupbasedpolicy neutron-mapper + + org.opendaylight.groupbasedpolicy + neutron-vpp-mapper + org.opendaylight.groupbasedpolicy neutron-ovsdb @@ -354,6 +358,12 @@ xml config + + org.opendaylight.groupbasedpolicy + neutron-vpp-mapper + xml + config + org.opendaylight.groupbasedpolicy neutron-ovsdb diff --git a/features/src/main/features/features.xml b/features/src/main/features/features.xml index 0177b8b1d..379b1c919 100755 --- a/features/src/main/features/features.xml +++ b/features/src/main/features/features.xml @@ -158,6 +158,16 @@ mvn:org.opendaylight.groupbasedpolicy/vpp-renderer/{{VERSION}}/xml/config + + + odl-groupbasedpolicy-neutronmapper + odl-groupbasedpolicy-vpp + mvn:org.opendaylight.groupbasedpolicy/neutron-vpp-mapper/{{VERSION}} + mvn:org.opendaylight.groupbasedpolicy/neutron-vpp-mapper/{{VERSION}}/xml/config + + diff --git a/neutron-vpp-mapper/pom.xml b/neutron-vpp-mapper/pom.xml new file mode 100644 index 000000000..705cbc89b --- /dev/null +++ b/neutron-vpp-mapper/pom.xml @@ -0,0 +1,87 @@ + + + + 4.0.0 + + + org.opendaylight.controller + config-parent + 0.5.0-SNAPSHOT + + + + org.opendaylight.groupbasedpolicy + neutron-vpp-mapper + 0.4.0-SNAPSHOT + bundle + + + 0.7.0-SNAPSHOT + + + + + + ${project.groupId} + groupbasedpolicy + ${project.version} + + + ${project.groupId} + neutron-mapper + ${project.version} + + + org.opendaylight.neutron + neutron-spi + ${neutron.version} + + + org.opendaylight.groupbasedpolicy + vpp-renderer + ${project.version} + + + + junit + junit + test + + + org.mockito + mockito-all + test + + + org.opendaylight.controller + sal-binding-broker-impl + test-jar + test + + + org.opendaylight.mdsal.model + ietf-yang-types-20130715 + + + + + + + org.apache.felix + maven-bundle-plugin + + + + * + + + + + + \ No newline at end of file diff --git a/neutron-vpp-mapper/src/main/config/default-config.xml b/neutron-vpp-mapper/src/main/config/default-config.xml new file mode 100644 index 000000000..2a196a59c --- /dev/null +++ b/neutron-vpp-mapper/src/main/config/default-config.xml @@ -0,0 +1,33 @@ + + + + + + + + + neutron-vpp-mapper:neutron-vpp-mapper-impl + + neutron-vpp-mapper-impl + + binding:binding-rpc-registry + binding-rpc-broker + + + binding:binding-async-data-broker + binding-data-broker + + + + + + + urn:opendaylight:params:xml:ns:yang:controller:config:neutron-vpp-mapper:impl?module=neutron-vpp-mapper-impl&revision=2016-04-25 + + diff --git a/neutron-vpp-mapper/src/main/java/org/opendaylight/controller/config/yang/config/neutron_vpp_mapper/impl/NeutronVppMapperModule.java b/neutron-vpp-mapper/src/main/java/org/opendaylight/controller/config/yang/config/neutron_vpp_mapper/impl/NeutronVppMapperModule.java new file mode 100644 index 000000000..6723613db --- /dev/null +++ b/neutron-vpp-mapper/src/main/java/org/opendaylight/controller/config/yang/config/neutron_vpp_mapper/impl/NeutronVppMapperModule.java @@ -0,0 +1,32 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.controller.config.yang.config.neutron_vpp_mapper.impl; + +import org.opendaylight.groupbasedpolicy.neutron.vpp.mapper.NeutronVppMapper; + +public class NeutronVppMapperModule extends org.opendaylight.controller.config.yang.config.neutron_vpp_mapper.impl.AbstractNeutronVppMapperModule { + public NeutronVppMapperModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver) { + super(identifier, dependencyResolver); + } + + public NeutronVppMapperModule(org.opendaylight.controller.config.api.ModuleIdentifier identifier, org.opendaylight.controller.config.api.DependencyResolver dependencyResolver, org.opendaylight.controller.config.yang.config.neutron_vpp_mapper.impl.NeutronVppMapperModule oldModule, java.lang.AutoCloseable oldInstance) { + super(identifier, dependencyResolver, oldModule, oldInstance); + } + + @Override + public void customValidation() { + } + + @Override + public java.lang.AutoCloseable createInstance() { + NeutronVppMapper neutronVppMapper = new NeutronVppMapper(getDataBrokerDependency()); + return neutronVppMapper; + } + +} diff --git a/neutron-vpp-mapper/src/main/java/org/opendaylight/controller/config/yang/config/neutron_vpp_mapper/impl/NeutronVppMapperModuleFactory.java b/neutron-vpp-mapper/src/main/java/org/opendaylight/controller/config/yang/config/neutron_vpp_mapper/impl/NeutronVppMapperModuleFactory.java new file mode 100644 index 000000000..b1c9cc5df --- /dev/null +++ b/neutron-vpp-mapper/src/main/java/org/opendaylight/controller/config/yang/config/neutron_vpp_mapper/impl/NeutronVppMapperModuleFactory.java @@ -0,0 +1,20 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ +/* +* Generated file +* +* Generated from: yang module name: neutron-vpp-mapper-impl yang module local name: neutron-vpp-mapper-impl +* Generated by: org.opendaylight.controller.config.yangjmxgenerator.plugin.JMXGenerator +* Generated at: Mon May 02 12:30:34 CEST 2016 +* +* Do not modify this file unless it is present under src/main directory +*/ +package org.opendaylight.controller.config.yang.config.neutron_vpp_mapper.impl; +public class NeutronVppMapperModuleFactory extends org.opendaylight.controller.config.yang.config.neutron_vpp_mapper.impl.AbstractNeutronVppMapperModuleFactory { + +} diff --git a/neutron-vpp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/NeutronVppMapper.java b/neutron-vpp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/NeutronVppMapper.java new file mode 100644 index 000000000..70f859f42 --- /dev/null +++ b/neutron-vpp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/NeutronVppMapper.java @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.groupbasedpolicy.neutron.vpp.mapper; + +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.groupbasedpolicy.neutron.vpp.mapper.processors.NeutronListener; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class NeutronVppMapper implements AutoCloseable { + + NeutronListener neutronListener; + private static final Logger LOG = LoggerFactory.getLogger(NeutronVppMapper.class); + + public NeutronVppMapper(DataBroker dataBroker) { + neutronListener = new NeutronListener(dataBroker); + LOG.info("Neutron VPP started!"); + } + + @Override + public void close() throws Exception { + neutronListener.close(); + } +} diff --git a/neutron-vpp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/BaseEndpointByPortListener.java b/neutron-vpp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/BaseEndpointByPortListener.java new file mode 100644 index 000000000..31f705048 --- /dev/null +++ b/neutron-vpp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/BaseEndpointByPortListener.java @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.groupbasedpolicy.neutron.vpp.mapper.processors; + +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.binding.api.DataObjectModification; +import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.groupbasedpolicy.util.DataTreeChangeHandler; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.Mappings; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.GbpByNeutronMappings; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.BaseEndpointsByPorts; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.base.endpoints.by.ports.BaseEndpointByPort; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class BaseEndpointByPortListener extends DataTreeChangeHandler implements MappingProvider { + + private final PortHandler portHandler; + + protected BaseEndpointByPortListener(PortHandler portHandler, DataBroker dataProvider) { + super(dataProvider); + this.portHandler = portHandler; + registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, + InstanceIdentifier.builder(Mappings.class) + .child(GbpByNeutronMappings.class) + .child(BaseEndpointsByPorts.class) + .child(BaseEndpointByPort.class) + .build())); + } + + @Override + public InstanceIdentifier getNeutronDtoIid() { + return portHandler.createWildcartedPortIid(); + } + + @Override + public void processCreatedNeutronDto(Port port) { + portHandler.processCreated(port); + } + + @Override + public void processUpdatedNeutronDto(Port original, Port delta) { + portHandler.processUpdated(original, delta); + } + + @Override + public void processDeletedNeutronDto(Port port) { + // handled by BaseEndpointByPort removal + } + + @Override + protected void onWrite(DataObjectModification rootNode, + InstanceIdentifier rootIdentifier) { + if (rootNode.getDataBefore() == null) { + portHandler.processCreated(rootNode.getDataAfter()); + } + } + + @Override + protected void onDelete(DataObjectModification rootNode, + InstanceIdentifier rootIdentifier) { + portHandler.processDeleted(rootNode.getDataBefore()); + } + + @Override + protected void onSubtreeModified(DataObjectModification rootNode, + InstanceIdentifier rootIdentifier) { + // update should not happen + } +} diff --git a/neutron-vpp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/MappingProvider.java b/neutron-vpp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/MappingProvider.java new file mode 100644 index 000000000..794dfac55 --- /dev/null +++ b/neutron-vpp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/MappingProvider.java @@ -0,0 +1,23 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.groupbasedpolicy.neutron.vpp.mapper.processors; + +import org.opendaylight.yangtools.yang.binding.DataObject; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +interface MappingProvider { + + InstanceIdentifier getNeutronDtoIid(); + + void processCreatedNeutronDto(T t); + + void processUpdatedNeutronDto(T original, T delta); + + void processDeletedNeutronDto(T t); +} diff --git a/neutron-vpp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/NeutronListener.java b/neutron-vpp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/NeutronListener.java new file mode 100644 index 000000000..d8b5073dd --- /dev/null +++ b/neutron-vpp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/NeutronListener.java @@ -0,0 +1,122 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.groupbasedpolicy.neutron.vpp.mapper.processors; + +import java.io.Closeable; +import java.util.ArrayList; +import java.util.Collection; +import java.util.LinkedHashSet; +import java.util.List; +import java.util.Set; +import java.util.concurrent.ExecutionException; + +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.binding.api.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.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 org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.collect.Iterators; +import com.google.common.collect.PeekingIterator; + +public class NeutronListener implements DataTreeChangeListener, Closeable { + + private static final Logger LOG = LoggerFactory.getLogger(NeutronListener.class); + + private final Set> dataChangeProviders = new LinkedHashSet<>(); + protected ListenerRegistration registeredListener; + + public NeutronListener(DataBroker dataBroker) { + registerHandlersAndListeners(dataBroker); + registeredListener = dataBroker.registerDataTreeChangeListener(new DataTreeIdentifier<>( + LogicalDatastoreType.CONFIGURATION, InstanceIdentifier.builder(Neutron.class).build()), this); + } + + private void registerHandlersAndListeners(DataBroker dataBroker) { + PortHandler portHandler = new PortHandler(dataBroker); + dataChangeProviders.add(new BaseEndpointByPortListener(portHandler, dataBroker)); + } + + @Override + public void onDataTreeChanged(Collection> changes) { + for (DataTreeModification change : changes) { + DataObjectModification rootNode = change.getRootNode(); + for (MappingProvider provider : dataChangeProviders) { + for (DataObjectModification modDto : findModifiedData(provider, rootNode)) { + try { + processChangedData(modDto, modDto.getModificationType(), provider); + } catch (InterruptedException | ExecutionException e) { + LOG.error("Failed to process {} modification of node: {}. {}", modDto.getModificationType(), + modDto.getIdentifier(), e.getStackTrace()); + } + } + } + } + } + + List> findModifiedData(MappingProvider provider, + DataObjectModification rootNode) { + List> modDtos = new ArrayList<>(); + PeekingIterator pathArgs = Iterators.peekingIterator(provider.getNeutronDtoIid() + .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(provider.getNeutronDtoIid().getTargetType())) { + modDtos.add(childDto); + } else { + modifDto = childDto; + break; + } + } + } + } + return modDtos; + } + + @SuppressWarnings("unchecked") + void processChangedData(DataObjectModification dto, ModificationType m, + MappingProvider processor) throws InterruptedException, ExecutionException { + switch (m) { + case WRITE: { + if (dto.getDataBefore() != null) { + processor.processUpdatedNeutronDto((T) dto.getDataBefore(), (T) dto.getDataAfter()); + } else { + processor.processCreatedNeutronDto((T) dto.getDataAfter()); + } + break; + } + case SUBTREE_MODIFIED: { + processor.processUpdatedNeutronDto((T) dto.getDataBefore(), (T) dto.getDataAfter()); + break; + } + case DELETE: { + processor.processDeletedNeutronDto((T) dto.getDataBefore()); + break; + } + } + } + + @Override + public void close() { + registeredListener.close(); + } +} diff --git a/neutron-vpp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/PortHandler.java b/neutron-vpp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/PortHandler.java new file mode 100644 index 000000000..2887a44cf --- /dev/null +++ b/neutron-vpp-mapper/src/main/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/PortHandler.java @@ -0,0 +1,163 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.groupbasedpolicy.neutron.vpp.mapper.processors; + +import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain; +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.binding.api.ReadTransaction; +import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; +import org.opendaylight.controller.md.sal.common.api.data.AsyncTransaction; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.controller.md.sal.common.api.data.TransactionChain; +import org.opendaylight.controller.md.sal.common.api.data.TransactionChainListener; +import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException; +import org.opendaylight.groupbasedpolicy.util.DataStoreHelper; +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.UniqueId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.Mappings; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.GbpByNeutronMappings; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.BaseEndpointsByPorts; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.base.endpoints.by.ports.BaseEndpointByPort; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.base.endpoints.by.ports.BaseEndpointByPortKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.Config; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpointBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpointKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.vpp.endpoint._interface.type.choice.VhostUserCaseBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.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.ports.rev150712.ports.attributes.ports.PortKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.google.common.annotations.VisibleForTesting; +import com.google.common.base.Optional; + +public class PortHandler implements TransactionChainListener { + + private static final Logger LOG = LoggerFactory.getLogger(MappingProvider.class); + + private BindingTransactionChain transactionChain; + BaseEndpointByPortListener portByBaseEpListener; + DataBroker dataBroker; + + PortHandler(DataBroker dataBroker) { + this.dataBroker = dataBroker; + transactionChain = this.dataBroker.createTransactionChain(this); + } + + void processCreated(Port port) { + ReadTransaction rTx = dataBroker.newReadOnlyTransaction(); + Optional optBaseEpByPort = DataStoreHelper.readFromDs(LogicalDatastoreType.OPERATIONAL, + createBaseEpByPortIid(port.getUuid()), rTx); + if (!optBaseEpByPort.isPresent()) { + return; + } + processCreatedData(port, optBaseEpByPort.get()); + } + + void processCreated(BaseEndpointByPort bebp) { + ReadTransaction rTx = dataBroker.newReadOnlyTransaction(); + Optional optPort = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, createPortIid( + bebp.getPortId()), rTx); + if (!optPort.isPresent()) { + return; + } + processCreatedData(optPort.get(), bebp); + } + + @VisibleForTesting + void processCreatedData(Port port, BaseEndpointByPort bebp) { + // port not used yet + VppEndpoint vppEp = buildVppEp(bebp); + writeVppEndpoint(createVppEndpointIid(vppEp.getKey()), vppEp, true); + LOG.debug("Created vpp-endpoint {}", vppEp); + } + + void processUpdated(Port original, Port delta) { + processCreated(delta); + } + + void processDeleted(BaseEndpointByPort bebp) { + VppEndpoint vppEp = buildVppEp(bebp); + writeVppEndpoint(createVppEndpointIid(vppEp.getKey()), vppEp, false); + LOG.debug("Deleted vpp-endpoint {}", vppEp); + } + + private void writeVppEndpoint(InstanceIdentifier vppEpIid, VppEndpoint vppEp, boolean created) { + WriteTransaction wTx = transactionChain.newWriteOnlyTransaction(); + InstanceIdentifier iid = createVppEndpointIid(vppEp.getKey()); + if (created == true) { + wTx.put(LogicalDatastoreType.CONFIGURATION, iid, vppEp, true); + } else { + wTx.delete(LogicalDatastoreType.CONFIGURATION, iid); + } + try { + wTx.submit().checkedGet(); + } catch (TransactionCommitFailedException e) { + LOG.error("Transaction chain commit failed. {}", e); + transactionChain.close(); + transactionChain = dataBroker.createTransactionChain(this); + } + } + + @VisibleForTesting + VppEndpoint buildVppEp(BaseEndpointByPort bebp) { + return new VppEndpointBuilder().setContextId(bebp.getContextId()) + .setContextType(bebp.getContextType()) + .setAddress(bebp.getAddress()) + .setInterfaceTypeChoice(new VhostUserCaseBuilder().setSocket(bebp.getPortId().getValue()).build()) + .setAddressType(bebp.getAddressType()) + .build(); + } + + private InstanceIdentifier createVppEndpointIid(VppEndpointKey vppEpKey) { + return InstanceIdentifier.builder(Config.class).child(VppEndpoint.class, vppEpKey).build(); + } + + private InstanceIdentifier createBaseEpByPortIid(Uuid uuid) { + return createBaseEpByPortIid(new UniqueId(uuid.getValue())); + } + + private InstanceIdentifier createBaseEpByPortIid(UniqueId uuid) { + return InstanceIdentifier.builder(Mappings.class) + .child(GbpByNeutronMappings.class) + .child(BaseEndpointsByPorts.class) + .child(BaseEndpointByPort.class, new BaseEndpointByPortKey(uuid)) + .build(); + } + + InstanceIdentifier createWildcartedPortIid() { + return portsIid().child(Port.class).build(); + } + + private InstanceIdentifier createPortIid(UniqueId uuid) { + return portsIid().child(Port.class, new PortKey(new Uuid(uuid.getValue()))).build(); + } + + private InstanceIdentifierBuilder portsIid() { + return InstanceIdentifier.builder(Neutron.class).child(Ports.class); + } + + @Override + public void onTransactionChainFailed(TransactionChain chain, AsyncTransaction transaction, + Throwable cause) { + LOG.error("Transaction chain failed. {}", cause.getMessage()); + transactionChain.close(); + transactionChain = dataBroker.createTransactionChain(this); + } + + @Override + public void onTransactionChainSuccessful(TransactionChain chain) { + LOG.trace("Transaction chain was successfull. {}", chain); + } +} diff --git a/neutron-vpp-mapper/src/main/yang/neutron-vpp-mapper-impl.yang b/neutron-vpp-mapper/src/main/yang/neutron-vpp-mapper-impl.yang new file mode 100644 index 000000000..86243d327 --- /dev/null +++ b/neutron-vpp-mapper/src/main/yang/neutron-vpp-mapper-impl.yang @@ -0,0 +1,52 @@ +module neutron-vpp-mapper-impl { + + yang-version 1; + namespace "urn:opendaylight:params:xml:ns:yang:controller:config:neutron-vpp-mapper:impl"; + prefix "neutron-vpp-mapper-impl"; + + import config { prefix config; revision-date 2013-04-05; } + import opendaylight-md-sal-binding { prefix mdsal; revision-date 2013-10-28; } + + description + "This module contains the base YANG definitions for + neutron-vpp-mapper implementation."; + + revision "2016-04-25" { + description + "Initial revision."; + } + + // This is the definition of the service implementation as a module identity. + identity neutron-vpp-mapper-impl { + base config:module-type; + + // Specifies the prefix for generated java classes. + config:java-name-prefix NeutronVppMapper; + } + + // Augments the 'configuration' choice node under modules/module. + augment "/config:modules/config:module/config:configuration" { + case neutron-vpp-mapper-impl { + when "/config:modules/config:module/config:type = 'neutron-vpp-mapper-impl'"; + + container data-broker { + uses config:service-ref { + refine type { + mandatory true; + config:required-identity mdsal:binding-async-data-broker; + } + } + } + + container rpc-registry { + uses config:service-ref { + refine type { + mandatory true; + config:required-identity mdsal:binding-rpc-registry; + } + } + } + + } + } +} \ No newline at end of file diff --git a/neutron-vpp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/NeutronListenerTest.java b/neutron-vpp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/NeutronListenerTest.java new file mode 100644 index 000000000..9ae9a197c --- /dev/null +++ b/neutron-vpp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/NeutronListenerTest.java @@ -0,0 +1,136 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.groupbasedpolicy.neutron.vpp.mapper.processors; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.verify; + +import java.util.Collection; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mockito; +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.binding.api.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.binding.api.WriteTransaction; +import org.opendaylight.controller.md.sal.binding.test.AbstractDataBrokerTest; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.groupbasedpolicy.neutron.mapper.util.MappingUtils; +import org.opendaylight.groupbasedpolicy.util.DataStoreHelper; +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.ContextId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.UniqueId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.MacAddressType; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.Mappings; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.GbpByNeutronMappings; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.BaseEndpointsByPorts; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.base.endpoints.by.ports.BaseEndpointByPort; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.base.endpoints.by.ports.BaseEndpointByPortBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.Config; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.PortBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron; +import org.opendaylight.yangtools.concepts.ListenerRegistration; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +public class NeutronListenerTest extends AbstractDataBrokerTest implements DataTreeChangeListener { + + private DataBroker dataBroker; + private Integer eventCount; + private static final LogicalDatastoreType CONFIG = LogicalDatastoreType.CONFIGURATION; + private static final LogicalDatastoreType OPER = LogicalDatastoreType.OPERATIONAL; + + private final Port port = new PortBuilder().setUuid(new Uuid("00000000-1111-2222-3333-444444444444")).build(); + private final BaseEndpointByPort bebp = new BaseEndpointByPortBuilder().setContextId( + new ContextId("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")) + .setAddress("00:11:11:11:11:11") + .setPortId(new UniqueId("00000000-1111-2222-3333-444444444444")) + .setContextType(MappingUtils.L2_BRDIGE_DOMAIN) + .setAddressType(MacAddressType.class) + .build(); + + @Before + public void init() { + dataBroker = getDataBroker(); + } + + @Test + public void constructorTest() { + dataBroker = Mockito.spy(dataBroker); + NeutronListener neutronListener = new NeutronListener(dataBroker); + verify(dataBroker).registerDataTreeChangeListener( + eq(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, + InstanceIdentifier.builder(Neutron.class) + .build())), any(NeutronListener.class)); + verify(dataBroker).registerDataTreeChangeListener( + eq(new DataTreeIdentifier<>(LogicalDatastoreType.OPERATIONAL, + InstanceIdentifier.builder(Mappings.class) + .child(GbpByNeutronMappings.class) + .child(BaseEndpointsByPorts.class) + .child(BaseEndpointByPort.class) + .build())), any(BaseEndpointByPortListener.class)); + neutronListener.close(); + } + + @Test + public void createAndDeleteTest() throws Exception { + eventCount = 0; + ListenerRegistration registerDataTreeChangeListener = registerVppEpListener(); + NeutronListener neutronListener = new NeutronListener(dataBroker); + WriteTransaction wTx = dataBroker.newWriteOnlyTransaction(); + wTx.put(CONFIG, TestUtils.createPortIid(port.getKey()), port); + wTx.put(OPER, TestUtils.createBaseEpByPortIid(port.getUuid()), bebp); + wTx.submit().get(); + wTx = dataBroker.newWriteOnlyTransaction(); + wTx.delete(CONFIG, TestUtils.createPortIid(port.getKey())); + wTx.delete(OPER, TestUtils.createBaseEpByPortIid(port.getUuid())); + DataStoreHelper.submitToDs(wTx); + // manual delay for max 5s + for (int i = 0; i < 50; i++) { + if (eventCount >= 2) { + break; + } + Thread.sleep(100); + } + assertEquals(Integer.valueOf(2), eventCount); + registerDataTreeChangeListener.close(); + neutronListener.close(); + } + + @Override + public void onDataTreeChanged(Collection> changes) { + for (DataTreeModification change : changes) { + DataObjectModification vppEpChange = change.getRootNode(); + ModificationType modType = vppEpChange.getModificationType(); + if (modType.equals(ModificationType.WRITE)) { + assertNull(vppEpChange.getDataBefore()); + assertNotNull(vppEpChange.getDataAfter()); + eventCount++; + } else if (modType.equals(ModificationType.DELETE)) { + assertNotNull(vppEpChange.getDataBefore()); + assertNull(vppEpChange.getDataAfter()); + eventCount++; + } + } + } + + private ListenerRegistration registerVppEpListener() { + return dataBroker.registerDataTreeChangeListener(new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION, + InstanceIdentifier.builder(Config.class).child(VppEndpoint.class).build()), this); + } +} diff --git a/neutron-vpp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/PortHandlerTest.java b/neutron-vpp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/PortHandlerTest.java new file mode 100644 index 000000000..aa92d28e4 --- /dev/null +++ b/neutron-vpp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/PortHandlerTest.java @@ -0,0 +1,128 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.groupbasedpolicy.neutron.vpp.mapper.processors; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.assertNotNull; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mockito; +import org.opendaylight.controller.md.sal.binding.api.BindingTransactionChain; +import org.opendaylight.controller.md.sal.binding.api.DataBroker; +import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; +import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction; +import org.opendaylight.controller.md.sal.binding.test.AbstractDataBrokerTest; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException; +import org.opendaylight.groupbasedpolicy.neutron.mapper.util.MappingUtils; +import org.opendaylight.groupbasedpolicy.util.DataStoreHelper; +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.ContextId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.UniqueId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.l2_l3.rev160427.MacAddressType; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.base.endpoints.by.ports.BaseEndpointByPort; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.base.endpoints.by.ports.BaseEndpointByPortBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.vpp.endpoint._interface.type.choice.VhostUserCase; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.Ports; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.Port; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.ports.rev150712.ports.attributes.ports.PortBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; + +import com.google.common.base.Optional; + +public class PortHandlerTest extends AbstractDataBrokerTest { + + private DataBroker dataBroker; + private PortHandler portHandler; + private ReadWriteTransaction rwTx; + private BindingTransactionChain transactionChain; + + private final Port port = new PortBuilder().setUuid(new Uuid("00000000-1111-2222-3333-444444444444")).build(); + private final BaseEndpointByPort bebp = new BaseEndpointByPortBuilder().setContextId( + new ContextId("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")) + .setAddress("00:11:11:11:11:11") + .setPortId(new UniqueId("00000000-1111-2222-3333-444444444444")) + .setContextType(MappingUtils.L2_BRDIGE_DOMAIN) + .setAddressType(MacAddressType.class) + .build(); + + @Before + public void init() { + dataBroker = Mockito.spy(getDataBroker()); + transactionChain = dataBroker.createTransactionChain(portHandler); + when(dataBroker.createTransactionChain(portHandler)).thenReturn(transactionChain); + portHandler = new PortHandler(dataBroker); + rwTx = Mockito.spy(dataBroker.newReadWriteTransaction()); + when(transactionChain.newWriteOnlyTransaction()).thenReturn(rwTx); + } + + @Test + public void buildVppEpTest() { + VppEndpoint vppEp = portHandler.buildVppEp(bebp); + assertEquals(vppEp.getAddress(),bebp.getAddress()); + assertEquals(vppEp.getAddressType(), bebp.getAddressType()); + assertEquals(vppEp.getContextId(), bebp.getContextId()); + assertEquals(vppEp.getContextType(), bebp.getContextType()); + assertTrue(vppEp.getInterfaceTypeChoice() instanceof VhostUserCase); + VhostUserCase vhostUserCase = (VhostUserCase) vppEp.getInterfaceTypeChoice(); + assertNotNull(vhostUserCase); + assertEquals(vhostUserCase.getSocket(), bebp.getPortId().getValue()); + } + + @Test + public void createWildcartedPortIidTest() throws TransactionCommitFailedException { + InstanceIdentifier iid = portHandler.createWildcartedPortIid(); + Class[] expectedTypes = {Neutron.class, Ports.class, Port.class}; + TestUtils.assertPathArgumentTypes(iid.getPathArguments(), expectedTypes); + assertEquals(iid.getTargetType(), Port.class); + } + + @Test + public void processCreatedDataTest() throws Exception { + portHandler.processCreatedData(port, bebp); + ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction(); + Optional optVppEp = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, + TestUtils.createVppEpIid(TestUtils.createVppEndpointKey(bebp)), rTx); + assertTrue(optVppEp.isPresent()); + } + + @Test + public void processUpdatedTest() throws Exception { + ReadWriteTransaction tx = dataBroker.newReadWriteTransaction(); + tx.put(LogicalDatastoreType.OPERATIONAL, TestUtils.createBaseEpByPortIid(port.getUuid()), bebp, true); + DataStoreHelper.submitToDs(tx); + portHandler.processUpdated(port, port); + ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction(); + Optional optVppEp = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, + TestUtils.createVppEpIid(TestUtils.createVppEndpointKey(bebp)), rTx); + assertTrue(optVppEp.isPresent()); + verify(rwTx).submit(); + } + + @Test + public void processDeletedTest() throws Exception { + ReadWriteTransaction tx = dataBroker.newReadWriteTransaction(); + tx.put(LogicalDatastoreType.OPERATIONAL, TestUtils.createVppEpIid(TestUtils.createVppEndpointKey(bebp)), + portHandler.buildVppEp(bebp)); + DataStoreHelper.submitToDs(tx); + portHandler.processDeleted(bebp); + ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction(); + Optional optVppEp = DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, + TestUtils.createVppEpIid(TestUtils.createVppEndpointKey(bebp)), rTx); + assertFalse(optVppEp.isPresent()); + verify(rwTx).submit(); + } +} diff --git a/neutron-vpp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/TestUtils.java b/neutron-vpp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/TestUtils.java new file mode 100644 index 000000000..6411071b4 --- /dev/null +++ b/neutron-vpp-mapper/src/test/java/org/opendaylight/groupbasedpolicy/neutron/vpp/mapper/processors/TestUtils.java @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +package org.opendaylight.groupbasedpolicy.neutron.vpp.mapper.processors; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; + +import java.util.Iterator; + +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.ContextId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.UniqueId; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.AddressType; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.forwarding.rev160427.ContextType; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.Mappings; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.GbpByNeutronMappings; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.BaseEndpointsByPorts; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.base.endpoints.by.ports.BaseEndpointByPort; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.gbp.by.neutron.mappings.base.endpoints.by.ports.BaseEndpointByPortKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.neutron.gbp.mapper.rev150513.mappings.neutron.by.gbp.mappings.PortsByEndpoints; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.Config; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpoint; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.config.VppEndpointKey; +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.ports.rev150712.ports.attributes.ports.PortKey; +import org.opendaylight.yang.gen.v1.urn.opendaylight.neutron.rev150712.Neutron; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument; + +public class TestUtils { + + public static VppEndpointKey createVppEndpointKey(BaseEndpointByPort bebp) { + return new VppEndpointKey(bebp.getAddress(), bebp.getAddressType(), bebp.getContextId(), bebp.getContextType()); + } + + public static InstanceIdentifier createVppEpIid(VppEndpointKey key) { + return InstanceIdentifier.builder(Config.class).child(VppEndpoint.class, key).build(); + } + + public static InstanceIdentifier createVppEpIid(String addr, Class addrType, + ContextId ctxId, Class ctxType) { + return createVppEpIid(new VppEndpointKey(addr, addrType, ctxId, ctxType)); + } + + public static InstanceIdentifier createPortIid(PortKey portKey) { + return InstanceIdentifier.builder(Neutron.class).child(Ports.class).child(Port.class, portKey).build(); + } + + public static InstanceIdentifier createBaseEpByPortIid(Uuid uuid) { + return createBaseEpByPortIid(new UniqueId(uuid.getValue())); + } + + public static InstanceIdentifier createBaseEpByPortIid(UniqueId uuid) { + return InstanceIdentifier.builder(Mappings.class) + .child(GbpByNeutronMappings.class) + .child(BaseEndpointsByPorts.class) + .child(BaseEndpointByPort.class, new BaseEndpointByPortKey(uuid)) + .build(); + } + + public static void assertPathArgumentTypes(Iterable pathArguments, Class[] expectedTypes) { + assertNotNull(pathArguments); + Iterator it = pathArguments.iterator(); + for (int i = 0; i < expectedTypes.length; ++i) { + assertTrue("Next path argument expected.", it.hasNext()); + assertEquals("Unexpected path argument type.", expectedTypes[i], it.next().getType()); + } + } +} diff --git a/pom.xml b/pom.xml index 257a4c8d5..3a306a984 100644 --- a/pom.xml +++ b/pom.xml @@ -21,6 +21,7 @@ renderers location-providers neutron-mapper + neutron-vpp-mapper neutron-ovsdb ui-backend groupbasedpolicy-ui diff --git a/renderers/vpp/pom.xml b/renderers/vpp/pom.xml index 0da97aaec..0a1df5f39 100644 --- a/renderers/vpp/pom.xml +++ b/renderers/vpp/pom.xml @@ -49,7 +49,7 @@ - org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp.input.rev160425.* + org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.vpp_renderer.rev160425.* --> diff --git a/renderers/vpp/src/main/yang/vpp-renderer.yang b/renderers/vpp/src/main/yang/vpp-renderer.yang new file mode 100644 index 000000000..283444aee --- /dev/null +++ b/renderers/vpp/src/main/yang/vpp-renderer.yang @@ -0,0 +1,41 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html + */ + +module vpp-renderer { + yang-version 1; + + namespace "urn:opendaylight:groupbasedpolicy:vpp_renderer"; + prefix "vpp-renderer"; + + description + "This module is a baseline for the group-based policy vpp renderer model."; + + revision "2016-04-25" { + description + "Initial revision."; + } + + import base-endpoint { prefix base-ep; revision-date 2016-04-27; } + + container config { + list vpp-endpoint { + key "context-type context-id address-type address"; + uses base-ep:address-endpoint-key; + choice interface-type-choice { + case vhost-user-case { + leaf socket { + description "A unique ID for the neutron port"; + type string { + length 1..255; + } + } + } + } + } + } +}