mdsalutil/mdsalutil-impl/src/main/java/org/opendaylight/vpnservice/mdsalutil/internal/MDSALManager.java

   1 /*
   2  * Copyright (c) 2013 Ericsson AB.  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
  10 package org.opendaylight.vpnservice.mdsalutil.internal;
  11
  12 import java.math.BigInteger;
  13 import java.util.ArrayList;
  14 import java.util.Collections;
  15 import java.util.List;
  16 import java.util.concurrent.atomic.AtomicInteger;
  17
  18 import org.opendaylight.vpnservice.mdsalutil.ActionInfo;
  19 import org.opendaylight.vpnservice.mdsalutil.ActionType;
  20 import org.opendaylight.vpnservice.mdsalutil.FlowEntity;
  21 import org.opendaylight.vpnservice.mdsalutil.GroupEntity;
  22 import org.opendaylight.vpnservice.mdsalutil.MDSALUtil;
  23 import org.opendaylight.vpnservice.mdsalutil.interfaces.IMdsalApiManager;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableBuilder;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupId;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.GroupKey;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
  45 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  46 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
  47 import org.slf4j.Logger;
  48 import org.slf4j.LoggerFactory;
  49 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  50 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  51 import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
  52 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  53 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  54
  55 import com.google.common.util.concurrent.CheckedFuture;
  56 import com.google.common.util.concurrent.FutureCallback;
  57 import com.google.common.util.concurrent.Futures;
  58
  59 public class MDSALManager implements IMdsalApiManager, AutoCloseable {
  60
  61     private static final Logger s_logger = LoggerFactory.getLogger(MDSALManager.class);
  62
  63     private DataBroker m_dataBroker;
  64
  65     private PacketProcessingService m_packetProcessingService;
  66
  67     private final AtomicInteger m_atomicInteger = new AtomicInteger();
  68
  69     //TODO : IF ID MANAGER IS RQD
  70
  71     /**
  72      * Writes the flows and Groups to the MD SAL DataStore
  73      * which will be sent to the openflowplugin for installing flows/groups on the switch.
  74      * Other modules of VPN service that wants to install flows / groups on the switch
  75      * uses this utility
  76      *
  77      * @param db - dataBroker reference
  78      * @param PacketProcessingService for sending the packet outs
  79      */
  80     public MDSALManager(final DataBroker db, PacketProcessingService pktProcService) {
  81         m_dataBroker = db;
  82         m_packetProcessingService = pktProcService;
  83
  84     }
  85
  86
  87     @Override
  88     public void close() throws Exception {
  89         s_logger.info("MDSAL Manager Closed");
  90     }
  91
  92     @Override
  93     public void printTest() {
  94
  95         s_logger.info(" INTER MODULECOMMUNICATION IS WORKING!!!!");
  96     }
  97     @Override
  98     public void installFlow(FlowEntity flowEntity) {
  99
 100         try {
 101             s_logger.info("within installFlow {}", flowEntity.getDpnId());
 102
 103             if (flowEntity.getCookie() == null) {
 104               //  s_logger.info("Helium_sync: Cookie is null");
 105                 flowEntity.setCookie(new BigInteger("0110000", 16));
 106             }
 107
 108             FlowKey flowKey = new FlowKey( new FlowId(flowEntity.getFlowId()) );
 109
 110             FlowBuilder flowbld = flowEntity.getFlowBuilder();
 111
 112             Flow flow = flowbld.build() ;
 113
 114             Node nodeDpn = buildDpnNode(flowEntity.getDpnId());
 115             InstanceIdentifier<Node> nodeInstanceId = InstanceIdentifier.builder(Nodes.class)
 116                     .child(Node.class, nodeDpn.getKey()).build();
 117
 118             InstanceIdentifier<Flow> flowInstanceId = InstanceIdentifier.builder(Nodes.class)
 119                     .child(Node.class, nodeDpn.getKey()).augmentation(FlowCapableNode.class)
 120                     .child(Table.class, new TableKey(flowEntity.getTableId())).child(Flow.class,flowKey).build();
 121
 122             String sTransactionUri = generateTransactionUri();
 123
 124             TableKey tableKey = new TableKey(flowEntity.getTableId() );
 125             InstanceIdentifier<Table> tableInstanceId = InstanceIdentifier.create(Nodes.class).child(Node.class, nodeDpn.getKey())
 126                     .augmentation(FlowCapableNode.class).child(Table.class, tableKey);
 127             Table table = new TableBuilder().setKey(tableKey).setFlow(Collections.<Flow>emptyList()).build();
 128
 129             WriteTransaction modification = m_dataBroker.newWriteOnlyTransaction();
 130
 131             //CHECK IF RQD
 132            // modification.put(LogicalDatastoreType.CONFIGURATION, nodeInstanceId, nodeDpn, true);
 133
 134
 135             modification.put(LogicalDatastoreType.CONFIGURATION, tableInstanceId, table);
 136
 137             modification.put(LogicalDatastoreType.CONFIGURATION, flowInstanceId, flowbld.build());
 138
 139             CheckedFuture<Void,TransactionCommitFailedException> submitFuture  = modification.submit();
 140
 141             Futures.addCallback(submitFuture, new FutureCallback<Void>() {
 142
 143                 @Override
 144                 public void onSuccess(final Void result) {
 145                     // Commited successfully
 146                     s_logger.info( "Install Flow -- Committedsuccessfully ") ;
 147                 }
 148
 149                 @Override
 150                 public void onFailure(final Throwable t) {
 151                     // Transaction failed
 152
 153                     if(t instanceof OptimisticLockFailedException) {
 154                         // Failed because of concurrent transaction modifying same data
 155                         s_logger.error( "Install Flow -- Failed because of concurrent transaction modifying same data ") ;
 156                     } else {
 157                        // Some other type of TransactionCommitFailedException
 158                         s_logger.error( "Install Flow -- Some other type of TransactionCommitFailedException " + t) ;
 159                     }
 160                 }
 161             });
 162         } catch (Exception e) {
 163             s_logger.error("Could not install flow: {}, exception: {}", flowEntity, e.getMessage());
 164         }
 165     }
 166
 167     @Override
 168     public void installGroup(GroupEntity groupEntity) {
 169         try {
 170             Group group = groupEntity.getGroupBuilder().build();
 171
 172             Node nodeDpn = buildDpnNode(groupEntity.getDpnId());
 173             InstanceIdentifier<Node> nodeInstanceId = InstanceIdentifier.builder(Nodes.class)
 174                     .child(Node.class, nodeDpn.getKey()).build();
 175             InstanceIdentifier<Group> groupInstanceId = InstanceIdentifier.builder(Nodes.class)
 176                     .child(Node.class, nodeDpn.getKey()).augmentation(FlowCapableNode.class)
 177                     .child(Group.class, new GroupKey(new GroupId(groupEntity.getGroupId()))).build();
 178
 179             WriteTransaction modification = m_dataBroker.newWriteOnlyTransaction();
 180
 181             //CHECK IF RQD
 182          //   modification.put(LogicalDatastoreType.CONFIGURATION, nodeInstanceId, nodeDpn);
 183             modification.put(LogicalDatastoreType.CONFIGURATION, groupInstanceId, group);
 184
 185             CheckedFuture<Void,TransactionCommitFailedException> submitFuture  = modification.submit();
 186
 187             Futures.addCallback(submitFuture, new FutureCallback<Void>() {
 188                 @Override
 189                 public void onSuccess(final Void result) {
 190                     // Commited successfully
 191                     s_logger.info( "Install Group -- Committedsuccessfully ") ;
 192                 }
 193
 194                 @Override
 195                 public void onFailure(final Throwable t) {
 196                     // Transaction failed
 197
 198                     if(t instanceof OptimisticLockFailedException) {
 199                         // Failed because of concurrent transaction modifying same data
 200                         s_logger.error( "Install Group -- Failed because of concurrent transaction modifying same data ") ;
 201                     } else {
 202                        // Some other type of TransactionCommitFailedException
 203                         s_logger.error( "Install Group -- Some other type of TransactionCommitFailedException " + t) ;
 204                     }
 205                 }
 206              });
 207            } catch (Exception e) {
 208             s_logger.error("Could not install Group: {}, exception: {}", groupEntity, e.getMessage());
 209             throw e;
 210         }
 211     }
 212
 213     @Override
 214     public void removeFlow(FlowEntity flowEntity) {
 215         try {
 216             Node nodeDpn = buildDpnNode(flowEntity.getDpnId());
 217             FlowKey flowKey = new FlowKey(new FlowId(flowEntity.getFlowId()));
 218             InstanceIdentifier<Flow> flowInstanceId = InstanceIdentifier.builder(Nodes.class)
 219                     .child(Node.class, nodeDpn.getKey()).augmentation(FlowCapableNode.class)
 220                     .child(Table.class, new TableKey(flowEntity.getTableId())).child(Flow.class, flowKey).build();
 221
 222
 223                 WriteTransaction modification = m_dataBroker.newWriteOnlyTransaction();
 224                 modification.delete(LogicalDatastoreType.CONFIGURATION,flowInstanceId );
 225
 226                 CheckedFuture<Void,TransactionCommitFailedException> submitFuture  = modification.submit();
 227
 228                 Futures.addCallback(submitFuture, new FutureCallback<Void>() {
 229                     @Override
 230                     public void onSuccess(final Void result) {
 231                         // Commited successfully
 232                         s_logger.info( "Delete Flow -- Committedsuccessfully ") ;
 233                     }
 234
 235                     @Override
 236                     public void onFailure(final Throwable t) {
 237                         // Transaction failed
 238                         if(t instanceof OptimisticLockFailedException) {
 239                             // Failed because of concurrent transaction modifying same data
 240                             s_logger.error( "Delete Flow -- Failed because of concurrent transaction modifying same data ") ;
 241                         } else {
 242                            // Some other type of TransactionCommitFailedException
 243                             s_logger.error( "Delete Flow -- Some other type of TransactionCommitFailedException " + t) ;
 244                         }
 245                     }
 246
 247                 });
 248         } catch (Exception e) {
 249             s_logger.error("Could not remove Flow: {}, exception: {}", flowEntity, e.getMessage());
 250         }
 251     }
 252
 253     @Override
 254     public void removeGroup(GroupEntity groupEntity) {
 255         try {
 256             Node nodeDpn = buildDpnNode(groupEntity.getDpnId());
 257             InstanceIdentifier<Group> groupInstanceId = InstanceIdentifier.builder(Nodes.class)
 258                     .child(Node.class, nodeDpn.getKey()).augmentation(FlowCapableNode.class)
 259                     .child(Group.class, new GroupKey(new GroupId(groupEntity.getGroupId()))).build();
 260
 261             WriteTransaction modification = m_dataBroker.newWriteOnlyTransaction();
 262
 263             modification.delete(LogicalDatastoreType.CONFIGURATION,groupInstanceId );
 264
 265             CheckedFuture<Void,TransactionCommitFailedException> submitFuture  = modification.submit();
 266
 267             Futures.addCallback(submitFuture, new FutureCallback<Void>() {
 268                 @Override
 269                 public void onSuccess(final Void result) {
 270                     // Commited successfully
 271                     s_logger.info( "Install Group -- Committedsuccessfully ") ;
 272                 }
 273
 274                 @Override
 275                 public void onFailure(final Throwable t) {
 276                     // Transaction failed
 277                     if(t instanceof OptimisticLockFailedException) {
 278                         // Failed because of concurrent transaction modifying same data
 279                         s_logger.error( "Install Group -- Failed because of concurrent transaction modifying same data ") ;
 280                     } else {
 281                        // Some other type of TransactionCommitFailedException
 282                         s_logger.error( "Install Group -- Some other type of TransactionCommitFailedException " + t) ;
 283                     }
 284                 }
 285             });
 286         } catch (Exception e) {
 287             s_logger.error("Could not remove Group: {}, exception: {}", groupEntity, e.getMessage());
 288         }
 289     }
 290
 291     @Override
 292     public void modifyGroup(GroupEntity groupEntity) {
 293
 294         installGroup(groupEntity);
 295     }
 296
 297     private String generateTransactionUri() {
 298         long lTransactionIdOut = m_atomicInteger.incrementAndGet();
 299
 300         // TO DO Introduce this later
 301       //  return "" + (lTransactionIdOut | m_lTransactionIdPrefix);
 302         return "" + (lTransactionIdOut );
 303     }
 304 /*
 305     private String generateTransactionUriForFlow(long nTransactionId) {
 306         long lTransactionIdOut = m_atomicInteger.incrementAndGet();
 307         return Long.toString((lTransactionIdOut | m_lTransactionIdPrefix)) + EUtil.TRANSACTION_ID_SEPARATOR
 308                 + Long.toString(nTransactionId);
 309     }
 310 */
 311
 312     @Override
 313     public void sendPacketOut(long lDpnId, int groupId, byte[] payload) {
 314
 315         List<ActionInfo> actionInfos = new ArrayList<ActionInfo>();
 316         actionInfos.add(new ActionInfo(ActionType.group, new String[] { String.valueOf(groupId) }));
 317
 318         sendPacketOutWithActions(lDpnId, groupId, payload, actionInfos);
 319     }
 320
 321     @Override
 322     public void sendPacketOutWithActions(long lDpnId, long groupId, byte[] payload, List<ActionInfo> actionInfos) {
 323
 324         m_packetProcessingService.transmitPacket(MDSALUtil.getPacketOut(actionInfos, payload, lDpnId,
 325                 getNodeConnRef("openflow:" + lDpnId, "0xfffffffd")));
 326     }
 327
 328     @Override
 329     public void sendARPPacketOutWithActions(long lDpnId, byte[] payload, List<ActionInfo> actions) {
 330
 331         m_packetProcessingService.transmitPacket(MDSALUtil.getPacketOut(actions, payload, lDpnId,
 332                 getNodeConnRef("openflow:" + lDpnId, "0xfffffffd")));
 333     }
 334
 335     private NodeKey getNodeKey(long dpId) {
 336         String nodeId = "openflow:" + dpId;
 337         NodeKey nodeKey = new NodeKey(new NodeId(nodeId));
 338         return nodeKey;
 339     }
 340
 341     public InstanceIdentifier<Node> nodeToInstanceId(Node node) {
 342         return InstanceIdentifier.builder(Nodes.class).child(Node.class, node.getKey()).toInstance();
 343     }
 344
 345     private static NodeConnectorRef getNodeConnRef(final String nodeId, final String port) {
 346         StringBuilder _stringBuilder = new StringBuilder(nodeId);
 347         StringBuilder _append = _stringBuilder.append(":");
 348         StringBuilder sBuild = _append.append(port);
 349         String _string = sBuild.toString();
 350         NodeConnectorId _nodeConnectorId = new NodeConnectorId(_string);
 351         NodeConnectorKey _nodeConnectorKey = new NodeConnectorKey(_nodeConnectorId);
 352         NodeConnectorKey nConKey = _nodeConnectorKey;
 353         InstanceIdentifierBuilder<Nodes> _builder = InstanceIdentifier.<Nodes> builder(Nodes.class);
 354         NodeId _nodeId = new NodeId(nodeId);
 355         NodeKey _nodeKey = new NodeKey(_nodeId);
 356         InstanceIdentifierBuilder<Node> _child = _builder.<Node, NodeKey> child(Node.class, _nodeKey);
 357         InstanceIdentifierBuilder<NodeConnector> _child_1 = _child.<NodeConnector, NodeConnectorKey> child(
 358                 NodeConnector.class, nConKey);
 359         InstanceIdentifier<NodeConnector> path = _child_1.toInstance();
 360         NodeConnectorRef _nodeConnectorRef = new NodeConnectorRef(path);
 361         return _nodeConnectorRef;
 362     }
 363
 364     private long getDpnIdFromNodeName(String nodeName) {
 365         String dpId = nodeName.substring(nodeName.lastIndexOf(":") + 1);
 366         return Long.parseLong(dpId);
 367     }
 368
 369     private Node buildDpnNode(long lDpnId) {
 370         NodeId nodeId = new NodeId("openflow:" + lDpnId);
 371         Node nodeDpn = new NodeBuilder().setId(nodeId).setKey(new NodeKey(nodeId)).build();
 372
 373         return nodeDpn;
 374     }
 375
 376 }