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