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