renderers/ofoverlay/src/main/java/org/opendaylight/groupbasedpolicy/renderer/ofoverlay/OFOverlayRenderer.java

   1 /*
   2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
   3  *
   4  * This program and the accompanying materials are made available under the
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html
   7  */
   8
   9 package org.opendaylight.groupbasedpolicy.renderer.ofoverlay;
  10
  11 import java.util.ArrayList;
  12 import java.util.List;
  13 import java.util.Map.Entry;
  14 import java.util.concurrent.ExecutionException;
  15 import java.util.concurrent.Executors;
  16 import java.util.concurrent.ScheduledExecutorService;
  17
  18 import javax.annotation.Nonnull;
  19
  20 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  21 import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
  22 import org.opendaylight.controller.md.sal.binding.api.NotificationService;
  23 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
  24 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  25 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
  26 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
  27 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  28 import org.opendaylight.groupbasedpolicy.api.EpRendererAugmentationRegistry;
  29 import org.opendaylight.groupbasedpolicy.api.PolicyValidatorRegistry;
  30 import org.opendaylight.groupbasedpolicy.api.StatisticsManager;
  31 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint.EndpointManager;
  32 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint.OfOverlayAug;
  33 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint.OfOverlayL3NatAug;
  34 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.node.SwitchManager;
  35 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.Action;
  36 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.ActionDefinitionListener;
  37 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.ClassifierDefinitionListener;
  38 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.SubjectFeatures;
  39 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.statistics.SflowClientSettingsListener;
  40 import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.service.rev130819.SalFlowService;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.common.rev140421.ActionDefinitionId;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayConfig;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayConfigBuilder;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.RendererName;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
  47 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  48 import org.opendaylight.yangtools.yang.binding.DataObject;
  49 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  50 import org.slf4j.Logger;
  51 import org.slf4j.LoggerFactory;
  52
  53 import com.google.common.base.Optional;
  54 import com.google.common.util.concurrent.Futures;
  55 import com.google.common.util.concurrent.ListenableFuture;
  56
  57 /**
  58  * Renderer that uses OpenFlow and OVSDB to implement an overlay network
  59  * using Open vSwitch.
  60  */
  61 public class OFOverlayRenderer implements AutoCloseable, DataChangeListener {
  62
  63     private static final Logger LOG =
  64             LoggerFactory.getLogger(OFOverlayRenderer.class);
  65     public static final RendererName RENDERER_NAME = new RendererName("OFOverlay");
  66
  67     private final DataBroker dataBroker;
  68     private final SwitchManager switchManager;
  69     private final EndpointManager endpointManager;
  70     private final PolicyManager policyManager;
  71     private final ClassifierDefinitionListener classifierDefinitionListener;
  72     private final SflowClientSettingsListener sflowClientSettingsListener;
  73     private ActionDefinitionListener actionDefinitionListener;
  74     private final OfOverlayAug ofOverlayAug;
  75     private final OfOverlayL3NatAug ofOverlayL3NatAug;
  76
  77     private final ScheduledExecutorService executor;
  78
  79     private static final InstanceIdentifier<OfOverlayConfig> configIid =
  80             InstanceIdentifier.builder(OfOverlayConfig.class).build();
  81
  82     ListenerRegistration<DataChangeListener> configReg;
  83
  84     public OFOverlayRenderer(final DataBroker dataProvider,
  85             PacketProcessingService packetProcessingService,
  86             SalFlowService flowService,
  87             NotificationService notificationService,
  88             EpRendererAugmentationRegistry epRendererAugmentationRegistry,
  89             PolicyValidatorRegistry policyValidatorRegistry,
  90             StatisticsManager statisticsManager,
  91             final short tableOffset) {
  92         super();
  93         this.dataBroker = dataProvider;
  94         int numCPU = Runtime.getRuntime().availableProcessors();
  95         //TODO: Consider moving to groupbasedpolicy-ofoverlay-config so as to be user configurable in distribution.
  96         executor = Executors.newScheduledThreadPool(numCPU * 2);
  97
  98         switchManager = new SwitchManager(dataProvider);
  99         endpointManager = new EndpointManager(dataProvider, packetProcessingService, flowService, notificationService,
 100                 executor, switchManager);
 101
 102         classifierDefinitionListener = new ClassifierDefinitionListener(dataBroker);
 103         actionDefinitionListener = new ActionDefinitionListener(dataProvider);
 104
 105         for (Entry<ActionDefinitionId, Action> entry : SubjectFeatures.getActions().entrySet()) {
 106             policyValidatorRegistry.register(entry.getKey(), entry.getValue());
 107         }
 108
 109         sflowClientSettingsListener = new SflowClientSettingsListener(dataProvider, executor, statisticsManager);
 110
 111         policyManager = new PolicyManager(dataProvider,
 112                 switchManager,
 113                 endpointManager,
 114                 executor,
 115                 tableOffset);
 116         ofOverlayAug = new OfOverlayAug(dataProvider, epRendererAugmentationRegistry);
 117         ofOverlayL3NatAug = new OfOverlayL3NatAug(epRendererAugmentationRegistry);
 118         Optional<OfOverlayConfig> config = readConfig();
 119         OfOverlayConfigBuilder configBuilder = new OfOverlayConfigBuilder();
 120         if (config.isPresent()) {
 121             configBuilder = new OfOverlayConfigBuilder(config.get());
 122         }
 123         registerConfigListener(dataProvider);
 124         if (configBuilder.getGbpOfoverlayTableOffset() == null) {
 125             configBuilder.setGbpOfoverlayTableOffset(tableOffset).build();
 126             writeTableOffset(configBuilder.build());
 127         }
 128
 129     }
 130
 131     public ScheduledExecutorService getExecutor() {
 132         return executor;
 133     }
 134
 135     // *************
 136     // AutoCloseable
 137     // *************
 138
 139     @Override
 140     public void close() throws Exception {
 141         executor.shutdownNow();
 142         if (configReg != null) configReg.close();
 143         if (switchManager != null) switchManager.close();
 144         if (endpointManager != null) endpointManager.close();
 145         if (classifierDefinitionListener != null) classifierDefinitionListener.close();
 146         if (actionDefinitionListener != null) actionDefinitionListener.close();
 147         if (ofOverlayAug != null) ofOverlayAug.close();
 148         if (ofOverlayL3NatAug != null) ofOverlayL3NatAug.close();
 149         if (policyManager != null) policyManager.close();
 150         if (sflowClientSettingsListener != null) sflowClientSettingsListener.close();
 151     }
 152
 153     // ******************
 154     // DataChangeListener
 155     // ******************
 156
 157     @Override
 158     public void onDataChanged(AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
 159         OfOverlayConfig config;
 160         try {
 161             for (Entry<InstanceIdentifier<?>, DataObject> entry : change.getCreatedData().entrySet()) {
 162                 if (entry.getValue() instanceof OfOverlayConfig) {
 163                     config = (OfOverlayConfig) entry.getValue();
 164                     applyConfig(config).get();
 165                     LOG.info("OF-Overlay config created: {}", config);
 166                 }
 167             }
 168             for (Entry<InstanceIdentifier<?>, DataObject> entry : change.getUpdatedData().entrySet()) {
 169                 if (entry.getValue() instanceof OfOverlayConfig) {
 170                     config = (OfOverlayConfig) entry.getValue();
 171                     applyConfig(config).get();
 172                     LOG.info("OF-Overlay config updated: {}", config);
 173                 }
 174             }
 175         } catch (InterruptedException | ExecutionException e) {
 176             LOG.error("Error occured while updating config for OF-Overlay Renderer.\n{}", e);
 177         }
 178     }
 179
 180     // **************
 181     // Implementation
 182     // **************
 183
 184     private void registerConfigListener(DataBroker dataProvider) {
 185         configReg =
 186                 dataProvider.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
 187                         configIid,
 188                         this,
 189                         DataChangeScope.SUBTREE);
 190     }
 191
 192     private Optional<OfOverlayConfig> readConfig() {
 193         final ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
 194         Optional<OfOverlayConfig> config =
 195                 DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,
 196                         configIid,
 197                         rTx);
 198         rTx.close();
 199         return config;
 200     }
 201
 202     private ListenableFuture<Void> writeTableOffset(OfOverlayConfig ofc) {
 203         WriteTransaction wTx = dataBroker.newWriteOnlyTransaction();
 204         wTx.merge(LogicalDatastoreType.CONFIGURATION, configIid, ofc, true);
 205         return wTx.submit();
 206     }
 207
 208     private ListenableFuture<List<Void>> applyConfig(@Nonnull OfOverlayConfig config) {
 209         List<ListenableFuture<Void>> configFutures = new ArrayList<>();
 210         // TODO add to list when implemented
 211         switchManager.setEncapsulationFormat(config.getEncapsulationFormat());
 212         endpointManager.setLearningMode(config.getLearningMode());
 213         policyManager.setLearningMode(config.getLearningMode());
 214         if (config.getGbpOfoverlayTableOffset() != null) {
 215             configFutures.add(policyManager.changeOpenFlowTableOffset(config.getGbpOfoverlayTableOffset()));
 216         }
 217         return Futures.allAsList(configFutures);
 218     }
 219 }