X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=renderers%2Fofoverlay%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fgroupbasedpolicy%2Frenderer%2Fofoverlay%2FOFOverlayRenderer.java;h=53b7c0747f12a083bb7be18862484203b564f482;hb=316ccb586e70922545fe4b5f4c6b80f823e1ab83;hp=067fcfb26ee1296b4a28bf26ce37195ccce4365d;hpb=c974839754c36cf5d1a5dec380dc1553714dcde1;p=groupbasedpolicy.git diff --git a/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/OFOverlayRenderer.java b/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/OFOverlayRenderer.java old mode 100644 new mode 100755 index 067fcfb26..53b7c0747 --- a/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/OFOverlayRenderer.java +++ b/renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/OFOverlayRenderer.java @@ -8,17 +8,41 @@ package org.opendaylight.groupbasedpolicy.renderer.ofoverlay; +import java.util.ArrayList; +import java.util.List; +import java.util.Map.Entry; +import java.util.concurrent.ExecutionException; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; +import javax.annotation.Nonnull; + import org.opendaylight.controller.md.sal.binding.api.DataBroker; import org.opendaylight.controller.md.sal.binding.api.DataChangeListener; +import org.opendaylight.controller.md.sal.binding.api.NotificationService; +import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction; +import org.opendaylight.controller.md.sal.binding.api.WriteTransaction; import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope; import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent; import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry; -import org.opendaylight.groupbasedpolicy.resolver.PolicyResolver; +import org.opendaylight.groupbasedpolicy.api.EpRendererAugmentationRegistry; +import org.opendaylight.groupbasedpolicy.api.PolicyValidatorRegistry; +import org.opendaylight.groupbasedpolicy.api.StatisticsManager; +import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint.EndpointManager; +import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint.OfOverlayAug; +import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint.OfOverlayL3NatAug; +import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.node.SwitchManager; +import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.Action; +import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.ActionDefinitionListener; +import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.ClassifierDefinitionListener; +import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.SubjectFeatures; +import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.SflowClientSettingsListener; +import org.opendaylight.groupbasedpolicy.util.DataStoreHelper; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ActionDefinitionId; import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayConfig; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayConfigBuilder; +import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.RendererName; import org.opendaylight.yangtools.concepts.ListenerRegistration; import org.opendaylight.yangtools.yang.binding.DataObject; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; @@ -26,71 +50,86 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.google.common.base.Optional; -import com.google.common.util.concurrent.FutureCallback; import com.google.common.util.concurrent.Futures; import com.google.common.util.concurrent.ListenableFuture; /** * Renderer that uses OpenFlow and OVSDB to implement an overlay network * using Open vSwitch. - * @author readams */ public class OFOverlayRenderer implements AutoCloseable, DataChangeListener { + private static final Logger LOG = LoggerFactory.getLogger(OFOverlayRenderer.class); + public static final RendererName RENDERER_NAME = new RendererName("OFOverlay"); private final DataBroker dataBroker; - private final PolicyResolver policyResolver; private final SwitchManager switchManager; private final EndpointManager endpointManager; private final PolicyManager policyManager; - private final SfcManager sfcManager; + private final ClassifierDefinitionListener classifierDefinitionListener; + private final SflowClientSettingsListener sflowClientSettingsListener; + private ActionDefinitionListener actionDefinitionListener; + private final OfOverlayAug ofOverlayAug; + private final OfOverlayL3NatAug ofOverlayL3NatAug; private final ScheduledExecutorService executor; private static final InstanceIdentifier configIid = InstanceIdentifier.builder(OfOverlayConfig.class).build(); - private OfOverlayConfig config; ListenerRegistration configReg; - public OFOverlayRenderer(DataBroker dataProvider, - RpcProviderRegistry rpcRegistry) { + public OFOverlayRenderer(final DataBroker dataProvider, + RpcProviderRegistry rpcRegistry, + NotificationService notificationService, + EpRendererAugmentationRegistry epRendererAugmentationRegistry, + PolicyValidatorRegistry policyValidatorRegistry, + StatisticsManager statisticsManager, + final short tableOffset) { super(); this.dataBroker = dataProvider; - int numCPU = Runtime.getRuntime().availableProcessors(); + //TODO: Consider moving to groupbasedpolicy-ofoverlay-config so as to be user configurable in distribution. executor = Executors.newScheduledThreadPool(numCPU * 2); - switchManager = new SwitchManager(dataProvider, executor); - endpointManager = new EndpointManager(dataProvider, rpcRegistry, - executor, switchManager); - policyResolver = new PolicyResolver(dataProvider, executor); + switchManager = new SwitchManager(dataProvider); + endpointManager = new EndpointManager(dataProvider, rpcRegistry, notificationService, + executor, switchManager); - policyManager = new PolicyManager(dataProvider, - policyResolver, - switchManager, - endpointManager, - rpcRegistry, - executor); - // TODO Move SfcManager out out ofoverlay renderer -- should be something - // that's shared by renderers, not specific to ofoverlay - sfcManager = new SfcManager(dataProvider, - policyResolver, - rpcRegistry, - executor); + classifierDefinitionListener = new ClassifierDefinitionListener(dataBroker); + actionDefinitionListener = new ActionDefinitionListener(dataProvider); + for (Entry entry : SubjectFeatures.getActions().entrySet()) { + policyValidatorRegistry.register(entry.getKey(), entry.getValue()); + } - configReg = - dataProvider.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION, - configIid, - this, - DataChangeScope.SUBTREE); - readConfig(); - LOG.info("Initialized OFOverlay renderer"); + sflowClientSettingsListener = new SflowClientSettingsListener(dataProvider, executor, statisticsManager); + + policyManager = new PolicyManager(dataProvider, + switchManager, + endpointManager, + executor, + tableOffset); + ofOverlayAug = new OfOverlayAug(dataProvider, epRendererAugmentationRegistry); + ofOverlayL3NatAug = new OfOverlayL3NatAug(epRendererAugmentationRegistry); + Optional config = readConfig(); + OfOverlayConfigBuilder configBuilder = new OfOverlayConfigBuilder(); + if (config.isPresent()) { + configBuilder = new OfOverlayConfigBuilder(config.get()); + } + registerConfigListener(dataProvider); + if (configBuilder.getGbpOfoverlayTableOffset() == null) { + configBuilder.setGbpOfoverlayTableOffset(tableOffset).build(); + writeTableOffset(configBuilder.build()); + } } + public ScheduledExecutorService getExecutor() { + return executor; + } + // ************* // AutoCloseable // ************* @@ -99,10 +138,14 @@ public class OFOverlayRenderer implements AutoCloseable, DataChangeListener { public void close() throws Exception { executor.shutdownNow(); if (configReg != null) configReg.close(); - if (policyResolver != null) policyResolver.close(); if (switchManager != null) switchManager.close(); if (endpointManager != null) endpointManager.close(); - if (sfcManager != null) sfcManager.close(); + if (classifierDefinitionListener != null) classifierDefinitionListener.close(); + if (actionDefinitionListener != null) actionDefinitionListener.close(); + if (ofOverlayAug != null) ofOverlayAug.close(); + if (ofOverlayL3NatAug != null) ofOverlayL3NatAug.close(); + if (policyManager != null) policyManager.close(); + if (sflowClientSettingsListener != null) sflowClientSettingsListener.close(); } // ****************** @@ -110,39 +153,65 @@ public class OFOverlayRenderer implements AutoCloseable, DataChangeListener { // ****************** @Override - public void onDataChanged(AsyncDataChangeEvent, - DataObject> change) { - readConfig(); + public void onDataChanged(AsyncDataChangeEvent, DataObject> change) { + OfOverlayConfig config; + try { + for (Entry, DataObject> entry : change.getCreatedData().entrySet()) { + if (entry.getValue() instanceof OfOverlayConfig) { + config = (OfOverlayConfig) entry.getValue(); + applyConfig(config).get(); + LOG.info("OF-Overlay config created: {}", config); + } + } + for (Entry, DataObject> entry : change.getUpdatedData().entrySet()) { + if (entry.getValue() instanceof OfOverlayConfig) { + config = (OfOverlayConfig) entry.getValue(); + applyConfig(config).get(); + LOG.info("OF-Overlay config updated: {}", config); + } + } + } catch (InterruptedException | ExecutionException e) { + LOG.error("Error occured while updating config for OF-Overlay Renderer.\n{}", e); + } } // ************** // Implementation // ************** - private void readConfig() { - ListenableFuture> dao = - dataBroker.newReadOnlyTransaction() - .read(LogicalDatastoreType.CONFIGURATION, configIid); - Futures.addCallback(dao, new FutureCallback>() { - @Override - public void onSuccess(final Optional result) { - if (!result.isPresent()) return; - if (result.get() instanceof OfOverlayConfig) { - config = (OfOverlayConfig)result.get(); - applyConfig(); - } - } + private void registerConfigListener(DataBroker dataProvider) { + configReg = + dataProvider.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION, + configIid, + this, + DataChangeScope.SUBTREE); + } - @Override - public void onFailure(Throwable t) { - LOG.error("Failed to read configuration", t); - } - }, executor); + private Optional readConfig() { + final ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction(); + Optional config = + DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION, + configIid, + rTx); + rTx.close(); + return config; + } + + private ListenableFuture writeTableOffset(OfOverlayConfig ofc) { + WriteTransaction wTx = dataBroker.newWriteOnlyTransaction(); + wTx.merge(LogicalDatastoreType.CONFIGURATION, configIid, ofc, true); + return wTx.submit(); } - private void applyConfig() { + private ListenableFuture> applyConfig(@Nonnull OfOverlayConfig config) { + List> configFutures = new ArrayList<>(); + // TODO add to list when implemented switchManager.setEncapsulationFormat(config.getEncapsulationFormat()); endpointManager.setLearningMode(config.getLearningMode()); policyManager.setLearningMode(config.getLearningMode()); + if (config.getGbpOfoverlayTableOffset() != null) { + configFutures.add(policyManager.changeOpenFlowTableOffset(config.getGbpOfoverlayTableOffset())); + } + return Futures.allAsList(configFutures); } }