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.controller.sal.binding.api.RpcProviderRegistry;
  29 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint.EndpointManager;
  30 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint.OfOverlayAug;
  31 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.endpoint.OfOverlayL3NatAug;
  32 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.node.SwitchManager;
  33 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.ActionDefinitionListener;
  34 import org.opendaylight.groupbasedpolicy.renderer.ofoverlay.sf.ClassifierDefinitionListener;
  35 import org.opendaylight.groupbasedpolicy.resolver.PolicyResolver;
  36 import org.opendaylight.groupbasedpolicy.util.DataStoreHelper;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayConfig;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayConfigBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.renderer.rev151103.RendererName;
  40 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  41 import org.opendaylight.yangtools.yang.binding.DataObject;
  42 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  43 import org.slf4j.Logger;
  44 import org.slf4j.LoggerFactory;
  45
  46 import com.google.common.base.Optional;
  47 import com.google.common.util.concurrent.Futures;
  48 import com.google.common.util.concurrent.ListenableFuture;
  49
  50 /**
  51  * Renderer that uses OpenFlow and OVSDB to implement an overlay network
  52  * using Open vSwitch.
  53
  54  */
  55 public class OFOverlayRenderer implements AutoCloseable, DataChangeListener {
  56     private static final Logger LOG =
  57             LoggerFactory.getLogger(OFOverlayRenderer.class);
  58     public static final RendererName RENDERER_NAME = new RendererName("OFOverlay");
  59
  60     private final DataBroker dataBroker;
  61     private final PolicyResolver policyResolver;
  62     private final SwitchManager switchManager;
  63     private final EndpointManager endpointManager;
  64     private final PolicyManager policyManager;
  65     private final ClassifierDefinitionListener classifierDefinitionListener;
  66     private ActionDefinitionListener actionDefinitionListener;
  67     private final OfOverlayAug ofOverlayAug;
  68     private final OfOverlayL3NatAug ofOverlayL3NatAug;
  69
  70     private final ScheduledExecutorService executor;
  71
  72     private static final InstanceIdentifier<OfOverlayConfig> configIid =
  73             InstanceIdentifier.builder(OfOverlayConfig.class).build();
  74
  75     ListenerRegistration<DataChangeListener> configReg;
  76
  77     public OFOverlayRenderer(final DataBroker dataProvider,
  78                              RpcProviderRegistry rpcRegistry,
  79                              NotificationService notificationService,
  80                              final short tableOffset) {
  81         super();
  82         this.dataBroker = dataProvider;
  83
  84         int numCPU = Runtime.getRuntime().availableProcessors();
  85         //TODO: Consider moving to groupbasedpolicy-ofoverlay-config so as to be user configurable in distribution.
  86         executor = Executors.newScheduledThreadPool(numCPU * 2);
  87
  88         switchManager = new SwitchManager(dataProvider);
  89         endpointManager = new EndpointManager(dataProvider, rpcRegistry, notificationService,
  90                                               executor, switchManager);
  91         policyResolver = new PolicyResolver(dataProvider);
  92
  93         classifierDefinitionListener = new ClassifierDefinitionListener(dataBroker);
  94         actionDefinitionListener = new ActionDefinitionListener(dataProvider);
  95
  96         // TODO we need register action/classifier validators to gpb-base
  97
  98         policyManager = new PolicyManager(dataProvider,
  99                                           switchManager,
 100                                           endpointManager,
 101                                           rpcRegistry,
 102                                           executor,
 103                                           tableOffset);
 104         ofOverlayAug = new OfOverlayAug(dataProvider);
 105         ofOverlayL3NatAug = new OfOverlayL3NatAug();
 106             Optional<OfOverlayConfig> config = readConfig();
 107             OfOverlayConfigBuilder configBuilder = new OfOverlayConfigBuilder();
 108             if (config.isPresent()) {
 109                 configBuilder = new OfOverlayConfigBuilder(config.get());
 110             }
 111             registerConfigListener(dataProvider);
 112             if (configBuilder.getGbpOfoverlayTableOffset() == null) {
 113                 configBuilder.setGbpOfoverlayTableOffset(tableOffset).build();
 114                 writeTableOffset(configBuilder.build());
 115             }
 116     }
 117
 118     // *************
 119     // AutoCloseable
 120     // *************
 121
 122     @Override
 123     public void close() throws Exception {
 124         executor.shutdownNow();
 125         if (configReg != null) configReg.close();
 126         if (policyResolver != null) policyResolver.close();
 127         if (switchManager != null) switchManager.close();
 128         if (endpointManager != null) endpointManager.close();
 129         if (classifierDefinitionListener != null) classifierDefinitionListener.close();
 130         if (actionDefinitionListener != null) actionDefinitionListener.close();
 131         if (ofOverlayAug != null) ofOverlayAug.close();
 132         if (ofOverlayL3NatAug != null) ofOverlayL3NatAug.close();
 133         if (policyManager != null) policyManager.close();
 134     }
 135
 136     // ******************
 137     // DataChangeListener
 138     // ******************
 139
 140     @Override
 141     public void onDataChanged(AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {
 142         OfOverlayConfig config;
 143         try {
 144             for (Entry<InstanceIdentifier<?>, DataObject> entry : change.getCreatedData().entrySet()) {
 145                 if (entry.getValue() instanceof OfOverlayConfig) {
 146                     config = (OfOverlayConfig) entry.getValue();
 147                     applyConfig(config).get();
 148                     LOG.info("OF-Overlay config created: {}", config);
 149                 }
 150             }
 151             for (Entry<InstanceIdentifier<?>, DataObject> entry : change.getUpdatedData().entrySet()) {
 152                 if (entry.getValue() instanceof OfOverlayConfig) {
 153                     config = (OfOverlayConfig) entry.getValue();
 154                     applyConfig(config).get();
 155                     LOG.info("OF-Overlay config updated: {}", config);
 156                 }
 157             }
 158         } catch (InterruptedException | ExecutionException e) {
 159             LOG.error("Error occured while updating config for OF-Overlay Renderer.\n{}", e);
 160         }
 161     }
 162
 163     // **************
 164     // Implementation
 165     // **************
 166
 167     private void registerConfigListener(DataBroker dataProvider) {
 168         configReg =
 169                 dataProvider.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
 170                                                         configIid,
 171                                                         this,
 172                                                         DataChangeScope.SUBTREE);
 173     }
 174
 175     private Optional<OfOverlayConfig> readConfig() {
 176         final ReadOnlyTransaction rTx = dataBroker.newReadOnlyTransaction();
 177         Optional<OfOverlayConfig> config =
 178                 DataStoreHelper.readFromDs(LogicalDatastoreType.CONFIGURATION,
 179                                            configIid,
 180                                            rTx);
 181         rTx.close();
 182         return config;
 183     }
 184
 185     private ListenableFuture<Void> writeTableOffset(OfOverlayConfig ofc) {
 186         WriteTransaction wTx = dataBroker.newWriteOnlyTransaction();
 187         wTx.merge(LogicalDatastoreType.CONFIGURATION, configIid, ofc, true);
 188         return wTx.submit();
 189     }
 190
 191     private ListenableFuture<List<Void>> applyConfig(@Nonnull OfOverlayConfig config) {
 192         List<ListenableFuture<Void>> configFutures = new ArrayList<>();
 193         // TODO add to list when implemented
 194         switchManager.setEncapsulationFormat(config.getEncapsulationFormat());
 195         endpointManager.setLearningMode(config.getLearningMode());
 196         policyManager.setLearningMode(config.getLearningMode());
 197         if (config.getGbpOfoverlayTableOffset() != null) {
 198             configFutures.add(policyManager.changeOpenFlowTableOffset(config.getGbpOfoverlayTableOffset()));
 199         }
 200         return Futures.allAsList(configFutures);
 201     }
 202 }