2 * Copyright (c) 2015, 2017 Cisco Systems, Inc. and others. All rights reserved.
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
8 package org.opendaylight.openflowplugin.impl.device;
10 import com.google.common.util.concurrent.ListenableFuture;
11 import io.netty.util.HashedWheelTimer;
12 import java.util.Optional;
14 import java.util.concurrent.ConcurrentHashMap;
15 import java.util.concurrent.ConcurrentMap;
16 import java.util.concurrent.ScheduledThreadPoolExecutor;
17 import java.util.concurrent.TimeUnit;
18 import javax.annotation.Nonnull;
19 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
20 import org.opendaylight.controller.md.sal.binding.api.NotificationPublishService;
21 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
22 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
23 import org.opendaylight.openflowjava.protocol.api.connection.OutboundQueueHandlerRegistration;
24 import org.opendaylight.openflowplugin.api.openflow.OFPContext;
25 import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
26 import org.opendaylight.openflowplugin.api.openflow.connection.OutboundQueueProvider;
27 import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
28 import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
29 import org.opendaylight.openflowplugin.api.openflow.device.DeviceManager;
30 import org.opendaylight.openflowplugin.api.openflow.device.TranslatorLibrary;
31 import org.opendaylight.openflowplugin.api.openflow.lifecycle.ContextChainHolder;
32 import org.opendaylight.openflowplugin.api.openflow.statistics.ofpspecific.MessageSpy;
33 import org.opendaylight.openflowplugin.extension.api.ExtensionConverterProviderKeeper;
34 import org.opendaylight.openflowplugin.extension.api.core.extension.ExtensionConverterProvider;
35 import org.opendaylight.openflowplugin.impl.connection.OutboundQueueProviderImpl;
36 import org.opendaylight.openflowplugin.impl.device.initialization.DeviceInitializerProvider;
37 import org.opendaylight.openflowplugin.impl.device.listener.OpenflowProtocolListenerFullImpl;
38 import org.opendaylight.openflowplugin.impl.util.DeviceInitializationUtil;
39 import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
40 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRemovedBuilder;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeUpdatedBuilder;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflow.provider.config.rev160510.OpenflowProviderConfig;
47 import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
48 import org.slf4j.Logger;
49 import org.slf4j.LoggerFactory;
51 public class DeviceManagerImpl implements DeviceManager, ExtensionConverterProviderKeeper {
53 private static final Logger LOG = LoggerFactory.getLogger(DeviceManagerImpl.class);
54 private static final int SPY_RATE = 10;
56 private final OpenflowProviderConfig config;
57 private final DataBroker dataBroker;
58 private final DeviceInitializerProvider deviceInitializerProvider;
59 private final ConvertorExecutor convertorExecutor;
60 private final ConcurrentMap<DeviceInfo, DeviceContext> deviceContexts = new ConcurrentHashMap<>();
61 private final Set<KeyedInstanceIdentifier<Node, NodeKey>> notificationCreateNodeSend =
62 ConcurrentHashMap.newKeySet();
63 private final NotificationPublishService notificationPublishService;
64 private final MessageSpy messageSpy;
65 private final HashedWheelTimer hashedWheelTimer;
66 private final Object updatePacketInRateLimitersLock = new Object();
67 private TranslatorLibrary translatorLibrary;
68 private ExtensionConverterProvider extensionConverterProvider;
69 private ScheduledThreadPoolExecutor spyPool;
70 private ContextChainHolder contextChainHolder;
72 public DeviceManagerImpl(@Nonnull final OpenflowProviderConfig config,
73 @Nonnull final DataBroker dataBroker,
74 @Nonnull final MessageSpy messageSpy,
75 @Nonnull final NotificationPublishService notificationPublishService,
76 @Nonnull final HashedWheelTimer hashedWheelTimer,
77 @Nonnull final ConvertorExecutor convertorExecutor,
78 @Nonnull final DeviceInitializerProvider deviceInitializerProvider) {
80 this.dataBroker = dataBroker;
81 this.deviceInitializerProvider = deviceInitializerProvider;
82 this.convertorExecutor = convertorExecutor;
83 this.hashedWheelTimer = hashedWheelTimer;
84 this.spyPool = new ScheduledThreadPoolExecutor(1);
85 this.notificationPublishService = notificationPublishService;
86 this.messageSpy = messageSpy;
87 DeviceInitializationUtil.makeEmptyNodes(dataBroker);
91 public TranslatorLibrary oook() {
92 return translatorLibrary;
96 public void setTranslatorLibrary(final TranslatorLibrary translatorLibrary) {
97 this.translatorLibrary = translatorLibrary;
101 public void close() {
102 deviceContexts.values().forEach(OFPContext::close);
103 deviceContexts.clear();
104 Optional.ofNullable(spyPool).ifPresent(ScheduledThreadPoolExecutor::shutdownNow);
110 public void initialize() {
111 spyPool.scheduleAtFixedRate(messageSpy, SPY_RATE, SPY_RATE, TimeUnit.SECONDS);
115 public void setExtensionConverterProvider(final ExtensionConverterProvider extensionConverterProvider) {
116 this.extensionConverterProvider = extensionConverterProvider;
120 public ExtensionConverterProvider getExtensionConverterProvider() {
121 return extensionConverterProvider;
125 public ListenableFuture<Void> removeDeviceFromOperationalDS(
126 @Nonnull final KeyedInstanceIdentifier<Node, NodeKey> ii) {
128 final WriteTransaction delWtx = dataBroker.newWriteOnlyTransaction();
129 delWtx.delete(LogicalDatastoreType.OPERATIONAL, ii);
130 return delWtx.submit();
135 public DeviceContext createContext(@Nonnull final ConnectionContext connectionContext) {
137 LOG.info("ConnectionEvent: Device connected to controller, Device:{}, NodeId:{}",
138 connectionContext.getConnectionAdapter().getRemoteAddress(),
139 connectionContext.getDeviceInfo().getNodeId());
141 connectionContext.getConnectionAdapter().setPacketInFiltering(true);
143 final OutboundQueueProvider outboundQueueProvider
144 = new OutboundQueueProviderImpl(connectionContext.getDeviceInfo().getVersion());
146 connectionContext.setOutboundQueueProvider(outboundQueueProvider);
147 final OutboundQueueHandlerRegistration<OutboundQueueProvider> outboundQueueHandlerRegistration =
148 connectionContext.getConnectionAdapter().registerOutboundQueueHandler(
149 outboundQueueProvider,
150 config.getBarrierCountLimit().getValue(),
151 TimeUnit.MILLISECONDS.toNanos(config.getBarrierIntervalTimeoutLimit().getValue()));
152 connectionContext.setOutboundQueueHandleRegistration(outboundQueueHandlerRegistration);
155 final DeviceContext deviceContext = new DeviceContextImpl(
161 config.isSkipTableFeatures(),
163 config.isUseSingleLayerSerialization(),
164 deviceInitializerProvider,
165 config.isEnableFlowRemovedNotification(),
166 config.isSwitchFeaturesMandatory(),
169 ((ExtensionConverterProviderKeeper) deviceContext).setExtensionConverterProvider(extensionConverterProvider);
170 deviceContext.setNotificationPublishService(notificationPublishService);
172 deviceContexts.put(connectionContext.getDeviceInfo(), deviceContext);
173 updatePacketInRateLimiters();
175 final OpenflowProtocolListenerFullImpl messageListener = new OpenflowProtocolListenerFullImpl(
176 connectionContext.getConnectionAdapter(), deviceContext);
178 connectionContext.getConnectionAdapter().setMessageListener(messageListener);
179 connectionContext.getConnectionAdapter().setAlienMessageListener(messageListener);
181 return deviceContext;
184 private void updatePacketInRateLimiters() {
185 synchronized (updatePacketInRateLimitersLock) {
186 final int deviceContextsSize = deviceContexts.size();
187 if (deviceContextsSize > 0) {
188 long freshNotificationLimit = config.getGlobalNotificationQuota() / deviceContextsSize;
189 if (freshNotificationLimit < 100) {
190 freshNotificationLimit = 100;
192 if (LOG.isDebugEnabled()) {
193 LOG.debug("fresh notification limit = {}", freshNotificationLimit);
195 for (final DeviceContext deviceContext : deviceContexts.values()) {
196 deviceContext.updatePacketInRateLimit(freshNotificationLimit);
203 public void onDeviceRemoved(final DeviceInfo deviceInfo) {
204 deviceContexts.remove(deviceInfo);
205 if (LOG.isDebugEnabled()) {
206 LOG.debug("Device context removed for node {}", deviceInfo);
209 this.updatePacketInRateLimiters();
213 public void sendNodeRemovedNotification(@Nonnull final KeyedInstanceIdentifier<Node, NodeKey> instanceIdentifier) {
214 if (notificationCreateNodeSend.remove(instanceIdentifier)) {
215 NodeRemovedBuilder builder = new NodeRemovedBuilder();
216 builder.setNodeRef(new NodeRef(instanceIdentifier));
217 LOG.info("Publishing node removed notification for {}", instanceIdentifier.firstKeyOf(Node.class).getId());
218 notificationPublishService.offerNotification(builder.build());
223 public void setContextChainHolder(@Nonnull ContextChainHolder contextChainHolder) {
224 this.contextChainHolder = contextChainHolder;
228 public void sendNodeAddedNotification(@Nonnull final KeyedInstanceIdentifier<Node, NodeKey> instanceIdentifier) {
229 if (!notificationCreateNodeSend.contains(instanceIdentifier)) {
230 notificationCreateNodeSend.add(instanceIdentifier);
231 final NodeId id = instanceIdentifier.firstKeyOf(Node.class).getId();
232 NodeUpdatedBuilder builder = new NodeUpdatedBuilder();
234 builder.setNodeRef(new NodeRef(instanceIdentifier));
235 LOG.info("Publishing node added notification for {}", id);
236 notificationPublishService.offerNotification(builder.build());