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