openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/device/initialization/OF10DeviceInitializer.java

   1 /*
   2  * Copyright (c) 2017 Pantheon Technologies s.r.o. 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.openflowplugin.impl.device.initialization;
  10
  11 import com.google.common.base.Function;
  12 import com.google.common.base.Preconditions;
  13 import com.google.common.util.concurrent.FutureCallback;
  14 import com.google.common.util.concurrent.Futures;
  15 import com.google.common.util.concurrent.ListenableFuture;
  16 import com.google.common.util.concurrent.MoreExecutors;
  17 import java.util.List;
  18 import java.util.concurrent.Future;
  19 import javax.annotation.Nonnull;
  20 import javax.annotation.Nullable;
  21 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  22 import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
  23 import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
  24 import org.opendaylight.openflowplugin.api.openflow.device.DeviceInfo;
  25 import org.opendaylight.openflowplugin.api.openflow.device.DeviceState;
  26 import org.opendaylight.openflowplugin.api.openflow.device.MessageTranslator;
  27 import org.opendaylight.openflowplugin.api.openflow.device.TxFacade;
  28 import org.opendaylight.openflowplugin.api.openflow.md.core.TranslatorKey;
  29 import org.opendaylight.openflowplugin.api.openflow.md.util.OpenflowVersion;
  30 import org.opendaylight.openflowplugin.impl.datastore.MultipartWriterProvider;
  31 import org.opendaylight.openflowplugin.impl.services.multilayer.MultiLayerMultipartCollectorService;
  32 import org.opendaylight.openflowplugin.impl.services.singlelayer.SingleLayerMultipartCollectorService;
  33 import org.opendaylight.openflowplugin.impl.util.DeviceInitializationUtil;
  34 import org.opendaylight.openflowplugin.impl.util.DeviceStateUtil;
  35 import org.opendaylight.openflowplugin.openflow.md.core.sal.convertor.ConvertorExecutor;
  36 import org.opendaylight.openflowplugin.openflow.md.util.InventoryDataServiceUtil;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.multipart.types.rev170112.MultipartReply;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.CapabilitiesV10;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MultipartType;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PortGrouping;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.FlowCapableNodeConnectorStatisticsData;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.FlowCapableNodeConnectorStatisticsDataBuilder;
  50 import org.opendaylight.yangtools.yang.common.RpcResult;
  51 import org.slf4j.Logger;
  52 import org.slf4j.LoggerFactory;
  53
  54 public class OF10DeviceInitializer extends AbstractDeviceInitializer {
  55
  56     private static final Logger LOG = LoggerFactory.getLogger(OF10DeviceInitializer.class);
  57
  58     @Override
  59     protected Future<Void> initializeNodeInformation(@Nonnull final DeviceContext deviceContext,
  60                                                      final boolean switchFeaturesMandatory,
  61                                                      final boolean skipTableFeatures,
  62                                                      @Nullable final MultipartWriterProvider multipartWriterProvider,
  63                                                      @Nullable final ConvertorExecutor convertorExecutor) {
  64         final ConnectionContext connectionContext =
  65                 Preconditions.checkNotNull(deviceContext.getPrimaryConnectionContext());
  66         final DeviceState deviceState = Preconditions.checkNotNull(deviceContext.getDeviceState());
  67         final DeviceInfo deviceInfo = Preconditions.checkNotNull(deviceContext.getDeviceInfo());
  68         final CapabilitiesV10 capabilitiesV10 = connectionContext.getFeatures().getCapabilitiesV10();
  69
  70         // Set capabilities for this device based on capabilities of connection context
  71         LOG.debug("Setting capabilities for device {}", deviceInfo);
  72         DeviceStateUtil.setDeviceStateBasedOnV10Capabilities(deviceState, capabilitiesV10);
  73         final ListenableFuture<Boolean> future = requestMultipart(MultipartType.OFPMPDESC, deviceContext);
  74
  75         Futures.addCallback(future, new FutureCallback<Boolean>() {
  76             @Override
  77             public void onSuccess(@Nullable final Boolean result) {
  78                 if (Boolean.TRUE.equals(result)) {
  79                     LOG.debug("Creating empty flow capable node: {}", deviceInfo);
  80                     makeEmptyFlowCapableNode(deviceContext, deviceInfo);
  81
  82                     LOG.debug("Creating empty tables for {}", deviceInfo);
  83                     DeviceInitializationUtil.makeEmptyTables(
  84                         deviceContext,
  85                         deviceInfo,
  86                         deviceContext.getPrimaryConnectionContext().getFeatures().getTables());
  87                 }
  88             }
  89
  90             @Override
  91             public void onFailure(@Nonnull final Throwable throwable) {
  92                 LOG.warn("Error occurred in preparation node {} for protocol 1.0", deviceInfo);
  93                 LOG.trace("Error for node {} : ", deviceInfo, throwable);
  94             }
  95         }, MoreExecutors.directExecutor());
  96
  97         return Futures.transform(future, new Function<Boolean, Void>() {
  98             @Nullable
  99             @Override
 100             public Void apply(@Nullable final Boolean input) {
 101                 LOG.debug("Writing physical port information for {}", deviceInfo);
 102                 writePhyPortInformation(deviceContext);
 103                 return null;
 104             }
 105         });
 106     }
 107
 108     @SuppressWarnings("checkstyle:IllegalCatch")
 109     private static void writePhyPortInformation(final DeviceContext deviceContext) {
 110         final DeviceInfo deviceInfo = deviceContext.getDeviceInfo();
 111         final ConnectionContext connectionContext = deviceContext.getPrimaryConnectionContext();
 112         final MessageTranslator<PortGrouping, FlowCapableNodeConnector> translator = deviceContext
 113             .oook()
 114             .lookupTranslator(new TranslatorKey(deviceInfo.getVersion(), PortGrouping.class.getName()));
 115
 116         connectionContext.getFeatures().getPhyPort().forEach(port -> {
 117             final NodeConnectorId nodeConnectorId = InventoryDataServiceUtil.nodeConnectorIdfromDatapathPortNo(
 118                 deviceInfo.getDatapathId(),
 119                 port.getPortNo(),
 120                 OpenflowVersion.get(deviceInfo.getVersion()));
 121
 122             try {
 123                 deviceContext.writeToTransaction(LogicalDatastoreType.OPERATIONAL,
 124                     deviceInfo
 125                         .getNodeInstanceIdentifier()
 126                         .child(NodeConnector.class, new NodeConnectorKey(nodeConnectorId)),
 127                     new NodeConnectorBuilder()
 128                         .setId(nodeConnectorId)
 129                         .addAugmentation(
 130                             FlowCapableNodeConnector.class,
 131                             translator.translate(port, deviceInfo, null))
 132                         .addAugmentation(
 133                             FlowCapableNodeConnectorStatisticsData.class,
 134                             new FlowCapableNodeConnectorStatisticsDataBuilder().build())
 135                         .build());
 136             } catch (final Exception e) {
 137                 LOG.debug("Failed to write node {} to DS ", deviceInfo, e);
 138             }
 139         });
 140     }
 141
 142     @SuppressWarnings("checkstyle:IllegalCatch")
 143     private static void makeEmptyFlowCapableNode(final TxFacade txFacade, final DeviceInfo deviceInfo) {
 144         try {
 145             txFacade.writeToTransaction(LogicalDatastoreType.OPERATIONAL,
 146                 deviceInfo
 147                     .getNodeInstanceIdentifier()
 148                     .augmentation(FlowCapableNode.class),
 149                 new FlowCapableNodeBuilder().build());
 150         } catch (final Exception e) {
 151             LOG.debug("Failed to write empty node {} to DS ", deviceInfo, e);
 152         }
 153     }
 154
 155     private static ListenableFuture<Boolean> requestMultipart(final MultipartType multipartType,
 156                                                               final DeviceContext deviceContext) {
 157         if (deviceContext.canUseSingleLayerSerialization()) {
 158             final SingleLayerMultipartCollectorService service =
 159                     new SingleLayerMultipartCollectorService(deviceContext, deviceContext);
 160
 161             return Futures.transform(service.handleServiceCall(multipartType),
 162                     new Function<RpcResult<List<MultipartReply>>, Boolean>() {
 163                         @Nonnull
 164                         @Override
 165                         public Boolean apply(final RpcResult<List<MultipartReply>> input) {
 166                             return input.isSuccessful();
 167                         }
 168                     });
 169         }
 170
 171         final MultiLayerMultipartCollectorService service =
 172                 new MultiLayerMultipartCollectorService(deviceContext, deviceContext);
 173
 174         return Futures.transform(service.handleServiceCall(multipartType),
 175                 new Function<RpcResult<List<org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol
 176                         .rev130731.MultipartReply>>, Boolean>() {
 177                     @Nonnull
 178                     @Override
 179                     public Boolean apply(final RpcResult<List<org.opendaylight.yang.gen.v1.urn.opendaylight.openflow
 180                             .protocol
 181                             .rev130731.MultipartReply>> input) {
 182                         return input.isSuccessful();
 183                     }
 184                 });
 185     }
 186
 187 }