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.concurrent.Executors;
  12 import java.util.concurrent.ScheduledExecutorService;
  13
  14 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  15 import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
  16 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
  17 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
  18 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  19 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
  20 import org.opendaylight.groupbasedpolicy.resolver.PolicyResolver;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.groupbasedpolicy.ofoverlay.rev140528.OfOverlayConfig;
  22 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  23 import org.opendaylight.yangtools.yang.binding.DataObject;
  24 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  25 import org.slf4j.Logger;
  26 import org.slf4j.LoggerFactory;
  27
  28 import com.google.common.base.Optional;
  29 import com.google.common.util.concurrent.FutureCallback;
  30 import com.google.common.util.concurrent.Futures;
  31 import com.google.common.util.concurrent.ListenableFuture;
  32
  33 /**
  34  * Renderer that uses OpenFlow and OVSDB to implement an overlay network
  35  * using Open vSwitch.
  36  * @author readams
  37  */
  38 public class OFOverlayRenderer implements AutoCloseable, DataChangeListener {
  39     private static final Logger LOG =
  40             LoggerFactory.getLogger(OFOverlayRenderer.class);
  41
  42     private final DataBroker dataBroker;
  43     private final PolicyResolver policyResolver;
  44     private final SwitchManager switchManager;
  45     private final EndpointManager endpointManager;
  46     private final PolicyManager policyManager;
  47     private final SfcManager sfcManager;
  48
  49     private final ScheduledExecutorService executor;
  50
  51     private static final InstanceIdentifier<OfOverlayConfig> configIid =
  52             InstanceIdentifier.builder(OfOverlayConfig.class).build();
  53
  54     private OfOverlayConfig config;
  55     ListenerRegistration<DataChangeListener> configReg;
  56
  57     public OFOverlayRenderer(DataBroker dataProvider,
  58                              RpcProviderRegistry rpcRegistry) {
  59         super();
  60         this.dataBroker = dataProvider;
  61
  62         int numCPU = Runtime.getRuntime().availableProcessors();
  63         executor = Executors.newScheduledThreadPool(numCPU * 2);
  64
  65         switchManager = new SwitchManager(dataProvider, executor);
  66         endpointManager = new EndpointManager(dataProvider, rpcRegistry,
  67                                               executor, switchManager);
  68         policyResolver = new PolicyResolver(dataProvider, executor);
  69
  70         policyManager = new PolicyManager(dataProvider,
  71                                           policyResolver,
  72                                           switchManager,
  73                                           endpointManager,
  74                                           rpcRegistry,
  75                                           executor);
  76         // TODO Move SfcManager out out ofoverlay renderer -- should be something
  77         //       that's shared by renderers, not specific to ofoverlay
  78         sfcManager = new SfcManager(dataProvider,
  79                                     policyResolver,
  80                                     rpcRegistry,
  81                                     executor);
  82
  83
  84         configReg =
  85                 dataProvider.registerDataChangeListener(LogicalDatastoreType.CONFIGURATION,
  86                                                         configIid,
  87                                                         this,
  88                                                         DataChangeScope.SUBTREE);
  89         readConfig();
  90         LOG.info("Initialized OFOverlay renderer");
  91
  92     }
  93
  94     // *************
  95     // AutoCloseable
  96     // *************
  97
  98     @Override
  99     public void close() throws Exception {
 100         executor.shutdownNow();
 101         if (configReg != null) configReg.close();
 102         if (policyResolver != null) policyResolver.close();
 103         if (switchManager != null) switchManager.close();
 104         if (endpointManager != null) endpointManager.close();
 105         if (sfcManager != null) sfcManager.close();
 106     }
 107
 108     // ******************
 109     // DataChangeListener
 110     // ******************
 111
 112     @Override
 113     public void onDataChanged(AsyncDataChangeEvent<InstanceIdentifier<?>,
 114                                                    DataObject> change) {
 115         readConfig();
 116     }
 117
 118     // **************
 119     // Implementation
 120     // **************
 121
 122     private void readConfig() {
 123         ListenableFuture<Optional<OfOverlayConfig>> dao =
 124                 dataBroker.newReadOnlyTransaction()
 125                     .read(LogicalDatastoreType.CONFIGURATION, configIid);
 126         Futures.addCallback(dao, new FutureCallback<Optional<OfOverlayConfig>>() {
 127             @Override
 128             public void onSuccess(final Optional<OfOverlayConfig> result) {
 129                 if (!result.isPresent()) return;
 130                 if (result.get() instanceof OfOverlayConfig) {
 131                     config = (OfOverlayConfig)result.get();
 132                     applyConfig();
 133                 }
 134             }
 135
 136             @Override
 137             public void onFailure(Throwable t) {
 138                 LOG.error("Failed to read configuration", t);
 139             }
 140         }, executor);
 141     }
 142
 143     private void applyConfig() {
 144         switchManager.setEncapsulationFormat(config.getEncapsulationFormat());
 145         endpointManager.setLearningMode(config.getLearningMode());
 146         policyManager.setLearningMode(config.getLearningMode());
 147     }
 148 }