openflowplugin-impl/src/main/java/org/opendaylight/openflowplugin/impl/util/DeviceInitializationUtils.java

   1 /*
   2  * Copyright (c) 2016 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.openflowplugin.impl.util;
  10
  11 import java.math.BigInteger;
  12 import java.net.Inet4Address;
  13 import java.net.Inet6Address;
  14 import java.net.InetAddress;
  15 import java.net.InetSocketAddress;
  16 import java.util.Arrays;
  17 import java.util.Collection;
  18 import java.util.Collections;
  19 import java.util.Iterator;
  20 import java.util.List;
  21 import java.util.concurrent.Future;
  22
  23 import com.google.common.base.Preconditions;
  24 import com.google.common.util.concurrent.AsyncFunction;
  25 import com.google.common.util.concurrent.FutureCallback;
  26 import com.google.common.util.concurrent.Futures;
  27 import com.google.common.util.concurrent.ListenableFuture;
  28 import com.google.common.util.concurrent.SettableFuture;
  29 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  30 import org.opendaylight.openflowjava.protocol.api.connection.OutboundQueue;
  31 import org.opendaylight.openflowplugin.api.ConnectionException;
  32 import org.opendaylight.openflowplugin.api.OFConstants;
  33 import org.opendaylight.openflowplugin.api.openflow.connection.ConnectionContext;
  34 import org.opendaylight.openflowplugin.api.openflow.device.DeviceContext;
  35 import org.opendaylight.openflowplugin.api.openflow.device.DeviceState;
  36 import org.opendaylight.openflowplugin.api.openflow.device.MessageTranslator;
  37 import org.opendaylight.openflowplugin.api.openflow.device.RequestContext;
  38 import org.opendaylight.openflowplugin.api.openflow.device.Xid;
  39 import org.opendaylight.openflowplugin.api.openflow.device.handlers.MultiMsgCollector;
  40 import org.opendaylight.openflowplugin.api.openflow.md.core.TranslatorKey;
  41 import org.opendaylight.openflowplugin.impl.common.MultipartRequestInputFactory;
  42 import org.opendaylight.openflowplugin.impl.common.NodeStaticReplyTranslatorUtil;
  43 import org.opendaylight.openflowplugin.impl.rpc.AbstractRequestContext;
  44 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.IpAddress;
  45 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv4Address;
  46 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.inet.types.rev100924.Ipv6Address;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeBuilder;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.FlowTableStatisticsData;
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.FlowTableStatisticsDataBuilder;
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.NodeGroupFeatures;
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorBuilder;
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;
  61 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.NodeMeterFeatures;
  62 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.Capabilities;
  63 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.CapabilitiesV10;
  64 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.common.types.rev130731.MultipartType;
  65 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.MultipartReply;
  66 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.OfHeader;
  67 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.PortGrouping;
  68 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.MultipartReplyBody;
  69 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyDescCase;
  70 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyGroupFeaturesCase;
  71 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyMeterFeaturesCase;
  72 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyPortDescCase;
  73 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.MultipartReplyTableFeaturesCase;
  74 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.multipart.reply.desc._case.MultipartReplyDesc;
  75 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.multipart.reply.group.features._case.MultipartReplyGroupFeatures;
  76 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.multipart.reply.meter.features._case.MultipartReplyMeterFeatures;
  77 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.multipart.reply.port.desc._case.MultipartReplyPortDesc;
  78 import org.opendaylight.yang.gen.v1.urn.opendaylight.openflow.protocol.rev130731.multipart.reply.multipart.reply.body.multipart.reply.table.features._case.MultipartReplyTableFeatures;
  79 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.FlowCapableNodeConnectorStatisticsData;
  80 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.FlowCapableNodeConnectorStatisticsDataBuilder;
  81 import org.opendaylight.yang.gen.v1.urn.opendaylight.table.types.rev131026.table.features.TableFeatures;
  82 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  83 import org.opendaylight.yangtools.yang.common.RpcError;
  84 import org.opendaylight.yangtools.yang.common.RpcResult;
  85 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  86 import org.slf4j.Logger;
  87 import org.slf4j.LoggerFactory;
  88
  89 public class DeviceInitializationUtils {
  90
  91     private static final Logger LOG = LoggerFactory.getLogger(DeviceInitializationUtils.class);
  92
  93     /**
  94      * InitializationNodeInformation is good to call only for MASTER otherwise we will have not empty transaction
  95      * for every Cluster Node (SLAVE too) and we will get race-condition by closing Connection.
  96      *
  97      * @param deviceContext
  98      * @param switchFeaturesMandatory
  99      * @return future - recommended to have blocking call for this future
 100      */
 101     public static ListenableFuture<Void> initializeNodeInformation(final DeviceContext deviceContext, final boolean switchFeaturesMandatory) {
 102         Preconditions.checkArgument(deviceContext != null);
 103         final DeviceState deviceState = Preconditions.checkNotNull(deviceContext.getDeviceState());
 104         final ConnectionContext connectionContext = Preconditions.checkNotNull(deviceContext.getPrimaryConnectionContext());
 105         final short version = deviceState.getVersion();
 106         LOG.trace("initalizeNodeInformation for node {}", deviceState.getNodeId());
 107         final SettableFuture<Void> returnFuture = SettableFuture.<Void> create();
 108         addNodeToOperDS(deviceContext, returnFuture);
 109         final ListenableFuture<List<RpcResult<List<MultipartReply>>>> deviceFeaturesFuture;
 110         if (OFConstants.OFP_VERSION_1_0 == version) {
 111             final CapabilitiesV10 capabilitiesV10 = connectionContext.getFeatures().getCapabilitiesV10();
 112
 113             DeviceStateUtil.setDeviceStateBasedOnV10Capabilities(deviceState, capabilitiesV10);
 114
 115             deviceFeaturesFuture = createDeviceFeaturesForOF10(deviceContext, deviceState);
 116             // create empty tables after device description is processed
 117             chainTableTrunkWriteOF10(deviceContext, deviceFeaturesFuture);
 118
 119             final short ofVersion = deviceContext.getDeviceState().getVersion();
 120             final TranslatorKey translatorKey = new TranslatorKey(ofVersion, PortGrouping.class.getName());
 121             final MessageTranslator<PortGrouping, FlowCapableNodeConnector> translator = deviceContext.oook()
 122                     .lookupTranslator(translatorKey);
 123             final BigInteger dataPathId = deviceContext.getPrimaryConnectionContext().getFeatures().getDatapathId();
 124
 125             for (final PortGrouping port : connectionContext.getFeatures().getPhyPort()) {
 126                 final FlowCapableNodeConnector fcNodeConnector = translator.translate(port, deviceContext, null);
 127
 128                 final NodeConnectorId nodeConnectorId = NodeStaticReplyTranslatorUtil.nodeConnectorId(
 129                         dataPathId.toString(), port.getPortNo(), ofVersion);
 130                 final NodeConnectorBuilder ncBuilder = new NodeConnectorBuilder().setId(nodeConnectorId);
 131                 ncBuilder.addAugmentation(FlowCapableNodeConnector.class, fcNodeConnector);
 132                 ncBuilder.addAugmentation(FlowCapableNodeConnectorStatisticsData.class,
 133                         new FlowCapableNodeConnectorStatisticsDataBuilder().build());
 134                 final NodeConnector connector = ncBuilder.build();
 135                 final InstanceIdentifier<NodeConnector> connectorII = deviceState.getNodeInstanceIdentifier().child(
 136                         NodeConnector.class, connector.getKey());
 137                 try {
 138                     deviceContext.writeToTransaction(LogicalDatastoreType.OPERATIONAL, connectorII, connector);
 139                 } catch (final Exception e) {
 140                     LOG.debug("Failed to write node {} to DS ", deviceContext.getDeviceState().getNodeId().toString(),
 141                             e);
 142                 }
 143
 144             }
 145         } else if (OFConstants.OFP_VERSION_1_3 == version) {
 146             final Capabilities capabilities = connectionContext.getFeatures().getCapabilities();
 147             LOG.debug("Setting capabilities for device {}", deviceContext.getDeviceState().getNodeId());
 148             DeviceStateUtil.setDeviceStateBasedOnV13Capabilities(deviceState, capabilities);
 149             deviceFeaturesFuture = createDeviceFeaturesForOF13(deviceContext, deviceState, switchFeaturesMandatory);
 150         } else {
 151             deviceFeaturesFuture = Futures.immediateFailedFuture(new ConnectionException("Unsupported version "
 152                     + version));
 153         }
 154
 155         Futures.addCallback(deviceFeaturesFuture, new FutureCallback<List<RpcResult<List<MultipartReply>>>>() {
 156             @Override
 157             public void onSuccess(final List<RpcResult<List<MultipartReply>>> result) {
 158                 LOG.debug("All init data for node {} is in submited.", deviceState.getNodeId());
 159                 returnFuture.set(null);
 160             }
 161
 162             @Override
 163             public void onFailure(final Throwable t) {
 164                 // FIXME : remove session
 165                 LOG.trace("Device capabilities gathering future failed.");
 166                 LOG.trace("more info in exploration failure..", t);
 167                 LOG.debug("All init data for node {} was not submited correctly - connection has to go down.", deviceState.getNodeId());
 168                 returnFuture.setException(t);
 169             }
 170         });
 171         return returnFuture;
 172     }
 173
 174     private static void addNodeToOperDS(final DeviceContext deviceContext, final SettableFuture<Void> future) {
 175         Preconditions.checkArgument(deviceContext != null);
 176         final DeviceState deviceState = deviceContext.getDeviceState();
 177         final NodeBuilder nodeBuilder = new NodeBuilder().setId(deviceState.getNodeId()).setNodeConnector(
 178                 Collections.<NodeConnector> emptyList());
 179         try {
 180             deviceContext.writeToTransaction(LogicalDatastoreType.OPERATIONAL, deviceState.getNodeInstanceIdentifier(),
 181                     nodeBuilder.build());
 182         } catch (final Exception e) {
 183             LOG.warn("Failed to write node {} to DS ", deviceState.getNodeId(), e);
 184             future.cancel(true);
 185         }
 186     }
 187
 188     private static ListenableFuture<List<RpcResult<List<MultipartReply>>>> createDeviceFeaturesForOF10(
 189             final DeviceContext deviceContext, final DeviceState deviceState) {
 190         final ListenableFuture<RpcResult<List<MultipartReply>>> replyDesc = getNodeStaticInfo(MultipartType.OFPMPDESC,
 191                 deviceContext, deviceState.getNodeInstanceIdentifier(), deviceState.getVersion());
 192
 193         return Futures.allAsList(Arrays.asList(replyDesc));
 194     }
 195
 196     private static ListenableFuture<List<RpcResult<List<MultipartReply>>>> createDeviceFeaturesForOF13(
 197             final DeviceContext deviceContext, final DeviceState deviceState, final boolean switchFeaturesMandatory) {
 198
 199         final ListenableFuture<RpcResult<List<MultipartReply>>> replyDesc = getNodeStaticInfo(MultipartType.OFPMPDESC,
 200                 deviceContext, deviceState.getNodeInstanceIdentifier(), deviceState.getVersion());
 201
 202         //first process description reply, write data to DS and write consequent data if successful
 203         return Futures.transform(replyDesc,
 204                 new AsyncFunction<RpcResult<List<MultipartReply>>, List<RpcResult<List<MultipartReply>>>>() {
 205                     @Override
 206                     public ListenableFuture<List<RpcResult<List<MultipartReply>>>> apply(
 207                             final RpcResult<List<MultipartReply>> rpcResult) throws Exception {
 208
 209                         translateAndWriteReply(MultipartType.OFPMPDESC, deviceContext,
 210                                 deviceState.getNodeInstanceIdentifier(), rpcResult.getResult());
 211
 212                         final ListenableFuture<RpcResult<List<MultipartReply>>> replyMeterFeature = getNodeStaticInfo(
 213                                 MultipartType.OFPMPMETERFEATURES, deviceContext,
 214                                 deviceState.getNodeInstanceIdentifier(), deviceState.getVersion());
 215
 216                         createSuccessProcessingCallback(MultipartType.OFPMPMETERFEATURES, deviceContext,
 217                                 deviceState.getNodeInstanceIdentifier(), replyMeterFeature);
 218
 219                         final ListenableFuture<RpcResult<List<MultipartReply>>> replyGroupFeatures = getNodeStaticInfo(
 220                                 MultipartType.OFPMPGROUPFEATURES, deviceContext,
 221                                 deviceState.getNodeInstanceIdentifier(), deviceState.getVersion());
 222                         createSuccessProcessingCallback(MultipartType.OFPMPGROUPFEATURES, deviceContext,
 223                                 deviceState.getNodeInstanceIdentifier(), replyGroupFeatures);
 224
 225                         final ListenableFuture<RpcResult<List<MultipartReply>>> replyTableFeatures = getNodeStaticInfo(
 226                                 MultipartType.OFPMPTABLEFEATURES, deviceContext,
 227                                 deviceState.getNodeInstanceIdentifier(), deviceState.getVersion());
 228                         createSuccessProcessingCallback(MultipartType.OFPMPTABLEFEATURES, deviceContext,
 229                                 deviceState.getNodeInstanceIdentifier(), replyTableFeatures);
 230
 231                         final ListenableFuture<RpcResult<List<MultipartReply>>> replyPortDescription = getNodeStaticInfo(
 232                                 MultipartType.OFPMPPORTDESC, deviceContext, deviceState.getNodeInstanceIdentifier(),
 233                                 deviceState.getVersion());
 234                         createSuccessProcessingCallback(MultipartType.OFPMPPORTDESC, deviceContext,
 235                                 deviceState.getNodeInstanceIdentifier(), replyPortDescription);
 236                         if (switchFeaturesMandatory) {
 237                             return Futures.allAsList(Arrays.asList(replyMeterFeature, replyGroupFeatures,
 238                                     replyTableFeatures, replyPortDescription));
 239                         } else {
 240                             return Futures.successfulAsList(Arrays.asList(replyMeterFeature, replyGroupFeatures,
 241                                     replyTableFeatures, replyPortDescription));
 242                         }
 243                     }
 244                 });
 245
 246     }
 247
 248     static void translateAndWriteReply(final MultipartType type, final DeviceContext dContext,
 249             final InstanceIdentifier<Node> nodeII, final Collection<MultipartReply> result) {
 250         try {
 251             for (final MultipartReply reply : result) {
 252                 final MultipartReplyBody body = reply.getMultipartReplyBody();
 253                 switch (type) {
 254                 case OFPMPDESC:
 255                     Preconditions.checkArgument(body instanceof MultipartReplyDescCase);
 256                     final MultipartReplyDesc replyDesc = ((MultipartReplyDescCase) body).getMultipartReplyDesc();
 257                     final FlowCapableNode fcNode = NodeStaticReplyTranslatorUtil.nodeDescTranslator(replyDesc,
 258                             getIpAddressOf(dContext));
 259                     final InstanceIdentifier<FlowCapableNode> fNodeII = nodeII.augmentation(FlowCapableNode.class);
 260                     dContext.writeToTransaction(LogicalDatastoreType.OPERATIONAL, fNodeII, fcNode);
 261                     break;
 262
 263                 case OFPMPTABLEFEATURES:
 264                     Preconditions.checkArgument(body instanceof MultipartReplyTableFeaturesCase);
 265                     final MultipartReplyTableFeatures tableFeatures = ((MultipartReplyTableFeaturesCase) body)
 266                             .getMultipartReplyTableFeatures();
 267                     final List<TableFeatures> tables = NodeStaticReplyTranslatorUtil
 268                             .nodeTableFeatureTranslator(tableFeatures);
 269                     for (final TableFeatures table : tables) {
 270                         final Short tableId = table.getTableId();
 271                         final InstanceIdentifier<Table> tableII = nodeII.augmentation(FlowCapableNode.class).child(
 272                                 Table.class, new TableKey(tableId));
 273                         final TableBuilder tableBuilder = new TableBuilder().setId(tableId).setTableFeatures(
 274                                 Collections.singletonList(table));
 275                         tableBuilder.addAugmentation(FlowTableStatisticsData.class,
 276                                 new FlowTableStatisticsDataBuilder().build());
 277                         dContext.writeToTransaction(LogicalDatastoreType.OPERATIONAL, tableII, tableBuilder.build());
 278                     }
 279                     break;
 280
 281                 case OFPMPMETERFEATURES:
 282                     Preconditions.checkArgument(body instanceof MultipartReplyMeterFeaturesCase);
 283                     final MultipartReplyMeterFeatures meterFeatures = ((MultipartReplyMeterFeaturesCase) body)
 284                             .getMultipartReplyMeterFeatures();
 285                     final NodeMeterFeatures mFeature = NodeStaticReplyTranslatorUtil
 286                             .nodeMeterFeatureTranslator(meterFeatures);
 287                     final InstanceIdentifier<NodeMeterFeatures> mFeatureII = nodeII
 288                             .augmentation(NodeMeterFeatures.class);
 289                     dContext.writeToTransaction(LogicalDatastoreType.OPERATIONAL, mFeatureII, mFeature);
 290                     if (0L < mFeature.getMeterFeatures().getMaxMeter().getValue()) {
 291                         dContext.getDeviceState().setMeterAvailable(true);
 292                     }
 293                     break;
 294
 295                 case OFPMPGROUPFEATURES:
 296                     Preconditions.checkArgument(body instanceof MultipartReplyGroupFeaturesCase);
 297                     final MultipartReplyGroupFeatures groupFeatures = ((MultipartReplyGroupFeaturesCase) body)
 298                             .getMultipartReplyGroupFeatures();
 299                     final NodeGroupFeatures gFeature = NodeStaticReplyTranslatorUtil
 300                             .nodeGroupFeatureTranslator(groupFeatures);
 301                     final InstanceIdentifier<NodeGroupFeatures> gFeatureII = nodeII
 302                             .augmentation(NodeGroupFeatures.class);
 303                     dContext.writeToTransaction(LogicalDatastoreType.OPERATIONAL, gFeatureII, gFeature);
 304                     break;
 305
 306                 case OFPMPPORTDESC:
 307                     Preconditions.checkArgument(body instanceof MultipartReplyPortDescCase);
 308                     final MultipartReplyPortDesc portDesc = ((MultipartReplyPortDescCase) body)
 309                             .getMultipartReplyPortDesc();
 310                     for (final PortGrouping port : portDesc.getPorts()) {
 311                         final short ofVersion = dContext.getDeviceState().getVersion();
 312                         final TranslatorKey translatorKey = new TranslatorKey(ofVersion, PortGrouping.class.getName());
 313                         final MessageTranslator<PortGrouping, FlowCapableNodeConnector> translator = dContext.oook()
 314                                 .lookupTranslator(translatorKey);
 315                         final FlowCapableNodeConnector fcNodeConnector = translator.translate(port, dContext, null);
 316
 317                         final BigInteger dataPathId = dContext.getPrimaryConnectionContext().getFeatures()
 318                                 .getDatapathId();
 319                         final NodeConnectorId nodeConnectorId = NodeStaticReplyTranslatorUtil.nodeConnectorId(
 320                                 dataPathId.toString(), port.getPortNo(), ofVersion);
 321                         final NodeConnectorBuilder ncBuilder = new NodeConnectorBuilder().setId(nodeConnectorId);
 322                         ncBuilder.addAugmentation(FlowCapableNodeConnector.class, fcNodeConnector);
 323
 324                         ncBuilder.addAugmentation(FlowCapableNodeConnectorStatisticsData.class,
 325                                 new FlowCapableNodeConnectorStatisticsDataBuilder().build());
 326                         final NodeConnector connector = ncBuilder.build();
 327
 328                         final InstanceIdentifier<NodeConnector> connectorII = nodeII.child(NodeConnector.class,
 329                                 connector.getKey());
 330                         dContext.writeToTransaction(LogicalDatastoreType.OPERATIONAL, connectorII, connector);
 331                     }
 332
 333                     break;
 334
 335                 default:
 336                     throw new IllegalArgumentException("Unnexpected MultipartType " + type);
 337                 }
 338             }
 339         } catch (final Exception e) {
 340             LOG.debug("Failed to write node {} to DS ", dContext.getDeviceState().getNodeId().toString(), e);
 341         }
 342     }
 343
 344     private static void createEmptyFlowCapableNodeInDs(final DeviceContext deviceContext) {
 345         final FlowCapableNodeBuilder flowCapableNodeBuilder = new FlowCapableNodeBuilder();
 346         final InstanceIdentifier<FlowCapableNode> fNodeII = deviceContext.getDeviceState().getNodeInstanceIdentifier()
 347                 .augmentation(FlowCapableNode.class);
 348         try {
 349             deviceContext.writeToTransaction(LogicalDatastoreType.OPERATIONAL, fNodeII, flowCapableNodeBuilder.build());
 350         } catch (final Exception e) {
 351             LOG.debug("Failed to write node {} to DS ", deviceContext.getDeviceState().getNodeId().toString(), e);
 352         }
 353     }
 354
 355     private static IpAddress getIpAddressOf(final DeviceContext deviceContext) {
 356
 357         final InetSocketAddress remoteAddress = deviceContext.getPrimaryConnectionContext().getConnectionAdapter()
 358                 .getRemoteAddress();
 359
 360         if (remoteAddress == null) {
 361             LOG.warn("IP address of the node {} cannot be obtained. No connection with switch.", deviceContext
 362                     .getDeviceState().getNodeId());
 363             return null;
 364         }
 365         LOG.info("IP address of switch is :" + remoteAddress);
 366
 367         final InetAddress address = remoteAddress.getAddress();
 368         final String hostAddress = address.getHostAddress();
 369         if (address instanceof Inet4Address) {
 370             return new IpAddress(new Ipv4Address(hostAddress));
 371         }
 372         if (address instanceof Inet6Address) {
 373             return new IpAddress(new Ipv6Address(hostAddress));
 374         }
 375         LOG.info("Illegal IP address {} of switch:{} ", address, deviceContext.getDeviceState().getNodeId());
 376         return null;
 377
 378     }
 379
 380     // FIXME : remove after ovs tableFeatures fix
 381     private static void makeEmptyTables(final DeviceContext dContext, final InstanceIdentifier<Node> nodeII,
 382             final Short nrOfTables) {
 383         LOG.debug("About to create {} empty tables.", nrOfTables);
 384         for (int i = 0; i < nrOfTables; i++) {
 385             final short tId = (short) i;
 386             final InstanceIdentifier<Table> tableII = nodeII.augmentation(FlowCapableNode.class).child(Table.class,
 387                     new TableKey(tId));
 388             final TableBuilder tableBuilder = new TableBuilder().setId(tId).addAugmentation(
 389                     FlowTableStatisticsData.class, new FlowTableStatisticsDataBuilder().build());
 390
 391             try {
 392                 dContext.writeToTransaction(LogicalDatastoreType.OPERATIONAL, tableII, tableBuilder.build());
 393             } catch (final Exception e) {
 394                 LOG.debug("Failed to write node {} to DS ", dContext.getDeviceState().getNodeId().toString(), e);
 395             }
 396
 397         }
 398     }
 399
 400     static void createSuccessProcessingCallback(final MultipartType type, final DeviceContext deviceContext,
 401             final InstanceIdentifier<Node> nodeII,
 402             final ListenableFuture<RpcResult<List<MultipartReply>>> requestContextFuture) {
 403         Futures.addCallback(requestContextFuture, new FutureCallback<RpcResult<List<MultipartReply>>>() {
 404             @Override
 405             public void onSuccess(final RpcResult<List<MultipartReply>> rpcResult) {
 406                 final List<MultipartReply> result = rpcResult.getResult();
 407                 if (result != null) {
 408                     LOG.info("Static node {} info: {} collected", deviceContext.getDeviceState().getNodeId(), type);
 409                     translateAndWriteReply(type, deviceContext, nodeII, result);
 410                 } else {
 411                     final Iterator<RpcError> rpcErrorIterator = rpcResult.getErrors().iterator();
 412                     while (rpcErrorIterator.hasNext()) {
 413                         final RpcError rpcError = rpcErrorIterator.next();
 414                         LOG.info("Failed to retrieve static node {} info: {}", type, rpcError.getMessage());
 415                         if (null != rpcError.getCause()) {
 416                             LOG.trace("Detailed error:", rpcError.getCause());
 417                         }
 418                     }
 419                     if (MultipartType.OFPMPTABLEFEATURES.equals(type)) {
 420                         makeEmptyTables(deviceContext, nodeII, deviceContext.getPrimaryConnectionContext()
 421                                 .getFeatures().getTables());
 422                     }
 423                 }
 424             }
 425
 426             @Override
 427             public void onFailure(final Throwable throwable) {
 428                 LOG.info("Request of type {} for static info of node {} failed.", type, nodeII);
 429             }
 430         });
 431     }
 432
 433     private static ListenableFuture<RpcResult<List<MultipartReply>>> getNodeStaticInfo(final MultipartType type,
 434             final DeviceContext deviceContext, final InstanceIdentifier<Node> nodeII, final short version) {
 435
 436         final OutboundQueue queue = deviceContext.getPrimaryConnectionContext().getOutboundQueueProvider();
 437
 438         final Long reserved = deviceContext.getReservedXid();
 439         final RequestContext<List<MultipartReply>> requestContext = new AbstractRequestContext<List<MultipartReply>>(
 440                 reserved) {
 441             @Override
 442             public void close() {
 443                 //NOOP
 444             }
 445         };
 446
 447         final Xid xid = requestContext.getXid();
 448
 449         LOG.trace("Hooking xid {} to device context - precaution.", reserved);
 450
 451         final MultiMsgCollector multiMsgCollector = deviceContext.getMultiMsgCollector(requestContext);
 452         queue.commitEntry(xid.getValue(),
 453                 MultipartRequestInputFactory.makeMultipartRequestInput(xid.getValue(), version, type),
 454                 new FutureCallback<OfHeader>() {
 455                     @Override
 456                     public void onSuccess(final OfHeader ofHeader) {
 457                         if (ofHeader instanceof MultipartReply) {
 458                             final MultipartReply multipartReply = (MultipartReply) ofHeader;
 459                             multiMsgCollector.addMultipartMsg(multipartReply);
 460                         } else if (null != ofHeader) {
 461                             LOG.info("Unexpected response type received {}.", ofHeader.getClass());
 462                         } else {
 463                             multiMsgCollector.endCollecting();
 464                             LOG.info("Response received is null.");
 465                         }
 466                     }
 467
 468                     @Override
 469                     public void onFailure(final Throwable t) {
 470                         LOG.info("Fail response from OutboundQueue for multipart type {}.", type);
 471                         final RpcResult<List<MultipartReply>> rpcResult = RpcResultBuilder
 472                                 .<List<MultipartReply>> failed().build();
 473                         requestContext.setResult(rpcResult);
 474                         if (MultipartType.OFPMPTABLEFEATURES.equals(type)) {
 475                             makeEmptyTables(deviceContext, nodeII, deviceContext.getPrimaryConnectionContext()
 476                                     .getFeatures().getTables());
 477                         }
 478                         requestContext.close();
 479                     }
 480                 });
 481
 482         return requestContext.getFuture();
 483     }
 484
 485     static void chainTableTrunkWriteOF10(final DeviceContext deviceContext,
 486             final ListenableFuture<List<RpcResult<List<MultipartReply>>>> deviceFeaturesFuture) {
 487         Futures.addCallback(deviceFeaturesFuture, new FutureCallback<List<RpcResult<List<MultipartReply>>>>() {
 488             @Override
 489             public void onSuccess(final List<RpcResult<List<MultipartReply>>> results) {
 490                 boolean allSucceeded = true;
 491                 for (final RpcResult<List<MultipartReply>> rpcResult : results) {
 492                     allSucceeded &= rpcResult.isSuccessful();
 493                 }
 494                 if (allSucceeded) {
 495                     createEmptyFlowCapableNodeInDs(deviceContext);
 496                     makeEmptyTables(deviceContext, deviceContext.getDeviceState().getNodeInstanceIdentifier(),
 497                             deviceContext.getDeviceState().getFeatures().getTables());
 498                 }
 499             }
 500
 501             @Override
 502             public void onFailure(final Throwable t) {
 503                 //NOOP
 504             }
 505         });
 506     }
 507 }