openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/connection/ConnectionManagerImpl.java

   1 /*
   2  * Copyright (c) 2015 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 package org.opendaylight.openflowplugin.impl.connection;
   9
  10 import com.google.common.annotations.VisibleForTesting;
  11 import com.google.common.base.Preconditions;
  12 import com.google.common.util.concurrent.ThreadFactoryBuilder;
  13 import java.math.BigInteger;
  14 import java.net.InetAddress;
  15 import java.time.LocalDateTime;
  16 import java.util.Collection;
  17 import java.util.Map;
  18 import java.util.concurrent.ConcurrentHashMap;
  19 import java.util.concurrent.ExecutorService;
  20 import java.util.concurrent.Executors;
  21 import java.util.concurrent.ThreadFactory;
  22 import org.eclipse.jdt.annotation.NonNull;
  23 import org.opendaylight.mdsal.binding.api.ClusteredDataTreeChangeListener;
  24 import org.opendaylight.mdsal.binding.api.DataBroker;
  25 import org.opendaylight.mdsal.binding.api.DataObjectModification;
  26 import org.opendaylight.mdsal.binding.api.DataTreeIdentifier;
  27 import org.opendaylight.mdsal.binding.api.DataTreeModification;
  28 import org.opendaylight.mdsal.binding.api.NotificationPublishService;
  29 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  30 import org.opendaylight.openflowjava.protocol.api.connection.ConnectionAdapter;
  31 import org.opendaylight.openflowjava.protocol.api.connection.ConnectionReadyListener;
  32 import org.opendaylight.openflowplugin.api.OFConstants;
  33 import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
  34 import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionManager;
  35 import org.opendaylight.openflowplugin.api.openflow.connection.DeviceConnectionStatusProvider;
  36 import org.opendaylight.openflowplugin.api.openflow.connection.HandshakeContext;
  37 import org.opendaylight.openflowplugin.api.openflow.device.handlers.DeviceConnectedHandler;
  38 import org.opendaylight.openflowplugin.api.openflow.device.handlers.DeviceDisconnectedHandler;
  39 import org.opendaylight.openflowplugin.api.openflow.md.core.HandshakeListener;
  40 import org.opendaylight.openflowplugin.api.openflow.md.core.HandshakeManager;
  41 import org.opendaylight.openflowplugin.impl.common.DeviceConnectionRateLimiter;
  42 import org.opendaylight.openflowplugin.impl.connection.listener.ConnectionReadyListenerImpl;
  43 import org.opendaylight.openflowplugin.impl.connection.listener.HandshakeListenerImpl;
  44 import org.opendaylight.openflowplugin.impl.connection.listener.OpenflowProtocolListenerInitialImpl;
  45 import org.opendaylight.openflowplugin.impl.connection.listener.SystemNotificationsListenerImpl;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.OpenflowProtocolListener;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.system.rev130927.SystemNotificationsListener;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.openflow.provider.config.rev160510.OpenflowProviderConfig;
  51 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  52 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  53 import org.slf4j.Logger;
  54 import org.slf4j.LoggerFactory;
  55
  56 public class ConnectionManagerImpl implements ConnectionManager {
  57
  58     private static final Logger LOG = LoggerFactory.getLogger(ConnectionManagerImpl.class);
  59     private static final Logger OF_EVENT_LOG = LoggerFactory.getLogger("OfEventLog");
  60     private static final boolean BITMAP_NEGOTIATION_ENABLED = true;
  61     private final ThreadFactory threadFactory = new ThreadFactoryBuilder()
  62             .setNameFormat("ConnectionHandler-%d")
  63             .setDaemon(false)
  64             .setUncaughtExceptionHandler((thread, ex) -> LOG.error("Uncaught exception {}", thread, ex))
  65             .build();
  66     private final ExecutorService executorsService = Executors.newCachedThreadPool(threadFactory);
  67
  68     private DeviceConnectedHandler deviceConnectedHandler;
  69     private final OpenflowProviderConfig config;
  70     private final ExecutorService executorService;
  71     private final DeviceConnectionRateLimiter deviceConnectionRateLimiter;
  72     private final DataBroker dataBroker;
  73     private final int deviceConnectionHoldTime;
  74     private DeviceDisconnectedHandler deviceDisconnectedHandler;
  75     private DeviceConnectionStatusProvider deviceConnectionStatusProvider;
  76     private final NotificationPublishService notificationPublishService;
  77
  78     public ConnectionManagerImpl(final OpenflowProviderConfig config, final ExecutorService executorService,
  79                                  final DataBroker dataBroker,
  80                                  @NonNull final NotificationPublishService notificationPublishService) {
  81         this.config = config;
  82         this.executorService = executorService;
  83         this.deviceConnectionRateLimiter = new DeviceConnectionRateLimiter(config);
  84         this.dataBroker = dataBroker;
  85         this.deviceConnectionHoldTime = config.getDeviceConnectionHoldTimeInSeconds().toJava();
  86         deviceConnectionStatusProvider = new DeviceConnectionStatusProviderImpl();
  87         deviceConnectionStatusProvider.init();
  88         this.notificationPublishService = notificationPublishService;
  89     }
  90
  91     @Override
  92     public void onSwitchConnected(final ConnectionAdapter connectionAdapter) {
  93         connectionAdapter.setExecutorService(executorsService);
  94         OF_EVENT_LOG.debug("OnSwitchConnected event received for device {}", connectionAdapter.getRemoteAddress());
  95         LOG.trace("prepare connection context");
  96         final ConnectionContext connectionContext = new ConnectionContextImpl(connectionAdapter,
  97                 deviceConnectionStatusProvider);
  98         connectionContext.setDeviceDisconnectedHandler(this.deviceDisconnectedHandler);
  99
 100         HandshakeListener handshakeListener = new HandshakeListenerImpl(connectionContext, deviceConnectedHandler);
 101         final HandshakeManager handshakeManager = createHandshakeManager(connectionAdapter, handshakeListener);
 102
 103         LOG.trace("prepare handshake context");
 104         HandshakeContext handshakeContext = new HandshakeContextImpl(executorService, handshakeManager);
 105         handshakeListener.setHandshakeContext(handshakeContext);
 106         connectionContext.setHandshakeContext(handshakeContext);
 107
 108         LOG.trace("prepare connection listeners");
 109         final ConnectionReadyListener connectionReadyListener = new ConnectionReadyListenerImpl(
 110                 connectionContext, handshakeContext);
 111         connectionAdapter.setConnectionReadyListener(connectionReadyListener);
 112
 113         final OpenflowProtocolListener ofMessageListener =
 114                 new OpenflowProtocolListenerInitialImpl(connectionContext, handshakeContext);
 115         connectionAdapter.setMessageListener(ofMessageListener);
 116
 117         final SystemNotificationsListener systemListener = new SystemNotificationsListenerImpl(connectionContext,
 118                 config.getEchoReplyTimeout().getValue().toJava(), executorService, notificationPublishService);
 119         connectionAdapter.setSystemListener(systemListener);
 120
 121         LOG.trace("connection ballet finished");
 122     }
 123
 124     private HandshakeManager createHandshakeManager(final ConnectionAdapter connectionAdapter,
 125                                                     final HandshakeListener handshakeListener) {
 126         HandshakeManagerImpl handshakeManager = new HandshakeManagerImpl(connectionAdapter,
 127                 OFConstants.VERSION_ORDER.get(0),
 128                 OFConstants.VERSION_ORDER, new ErrorHandlerSimpleImpl(), handshakeListener, BITMAP_NEGOTIATION_ENABLED,
 129                 deviceConnectionRateLimiter, deviceConnectionHoldTime, deviceConnectionStatusProvider);
 130
 131         return handshakeManager;
 132     }
 133
 134     @Override
 135     public boolean accept(final InetAddress switchAddress) {
 136         // TODO add connection accept logic based on address
 137         return true;
 138     }
 139
 140     @Override
 141     public void setDeviceConnectedHandler(final DeviceConnectedHandler deviceConnectedHandler) {
 142         this.deviceConnectedHandler = deviceConnectedHandler;
 143     }
 144
 145     @Override
 146     public void setDeviceDisconnectedHandler(final DeviceDisconnectedHandler deviceDisconnectedHandler) {
 147         this.deviceDisconnectedHandler = deviceDisconnectedHandler;
 148     }
 149
 150     @VisibleForTesting
 151     DeviceConnectionStatusProvider getDeviceConnectionStatusProvider() {
 152         return deviceConnectionStatusProvider;
 153     }
 154
 155     @Override
 156     public void close() throws Exception {
 157         if (deviceConnectionStatusProvider != null) {
 158             deviceConnectionStatusProvider.close();
 159             deviceConnectionStatusProvider = null;
 160         }
 161         if (executorsService != null) {
 162             executorsService.shutdownNow();
 163         }
 164     }
 165
 166     class DeviceConnectionStatusProviderImpl implements DeviceConnectionStatusProvider,
 167             ClusteredDataTreeChangeListener<Node> {
 168         private final Map<BigInteger, LocalDateTime> deviceConnectionMap = new ConcurrentHashMap<>();
 169
 170         private ListenerRegistration<DeviceConnectionStatusProviderImpl> listenerRegistration;
 171
 172         @Override
 173         @SuppressWarnings({"checkstyle:IllegalCatch"})
 174         public void init() {
 175             DataTreeIdentifier<Node> treeId = DataTreeIdentifier.create(LogicalDatastoreType.OPERATIONAL,
 176                     getWildCardPath());
 177             try {
 178                 listenerRegistration = dataBroker.registerDataTreeChangeListener(treeId, this);
 179             } catch (Exception e) {
 180                 LOG.error("DeviceConnectionStatusProvider listener registration failed", e);
 181             }
 182         }
 183
 184         @Override
 185         public LocalDateTime getDeviceLastConnectionTime(BigInteger nodeId) {
 186             return deviceConnectionMap.get(nodeId);
 187         }
 188
 189         @Override
 190         public void addDeviceLastConnectionTime(BigInteger nodeId, LocalDateTime time) {
 191             deviceConnectionMap.put(nodeId, time);
 192         }
 193
 194         @Override
 195         public void removeDeviceLastConnectionTime(BigInteger nodeId) {
 196             deviceConnectionMap.remove(nodeId);
 197         }
 198
 199         @Override
 200         public void onDataTreeChanged(@NonNull Collection<DataTreeModification<Node>> changes) {
 201             Preconditions.checkNotNull(changes, "Changes must not be null!");
 202             for (DataTreeModification<Node> change : changes) {
 203                 final DataObjectModification<Node> mod = change.getRootNode();
 204                 switch (mod.getModificationType()) {
 205                     case DELETE:
 206                         break;
 207                     case SUBTREE_MODIFIED:
 208                         break;
 209                     case WRITE:
 210                         processNodeModification(change);
 211                         break;
 212                     default:
 213                         throw new IllegalArgumentException("Unhandled modification type " + mod.getModificationType());
 214                 }
 215             }
 216         }
 217
 218         private InstanceIdentifier<Node> getWildCardPath() {
 219             return InstanceIdentifier.create(Nodes.class).child(Node.class);
 220         }
 221
 222         private void processNodeModification(DataTreeModification<Node> change) {
 223             final InstanceIdentifier<Node> key = change.getRootPath().getRootIdentifier();
 224             final InstanceIdentifier<Node> nodeIdent = key.firstIdentifierOf(Node.class);
 225             String[] nodeIdentity = nodeIdent.firstKeyOf(Node.class).getId().getValue().split(":");
 226             String nodeId = nodeIdentity[1];
 227             LOG.info("Clearing the device connection timer for the device {}", nodeId);
 228             removeDeviceLastConnectionTime(new BigInteger(nodeId));
 229         }
 230
 231         @Override
 232         public void close() {
 233             if (listenerRegistration != null) {
 234                 listenerRegistration.close();
 235                 listenerRegistration = null;
 236             }
 237         }
 238     }
 239 }