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 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 pktProcService- 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
  93     public void printTest() {
  94
  95         s_logger.info(" INTER MODULECOMMUNICATION IS WORKING!!!!");
  96     }
  97
  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     public void installGroup(GroupEntity groupEntity) {
 168         try {
 169             Group group = groupEntity.getGroupBuilder().build();
 170
 171             Node nodeDpn = buildDpnNode(groupEntity.getDpnId());
 172             InstanceIdentifier<Node> nodeInstanceId = InstanceIdentifier.builder(Nodes.class)
 173                     .child(Node.class, nodeDpn.getKey()).build();
 174             InstanceIdentifier<Group> groupInstanceId = InstanceIdentifier.builder(Nodes.class)
 175                     .child(Node.class, nodeDpn.getKey()).augmentation(FlowCapableNode.class)
 176                     .child(Group.class, new GroupKey(new GroupId(groupEntity.getGroupId()))).build();
 177
 178             WriteTransaction modification = m_dataBroker.newWriteOnlyTransaction();
 179
 180             //CHECK IF RQD
 181          //   modification.put(LogicalDatastoreType.CONFIGURATION, nodeInstanceId, nodeDpn);
 182             modification.put(LogicalDatastoreType.CONFIGURATION, groupInstanceId, group);
 183
 184             CheckedFuture<Void,TransactionCommitFailedException> submitFuture  = modification.submit();
 185
 186             Futures.addCallback(submitFuture, new FutureCallback<Void>() {
 187                 @Override
 188                 public void onSuccess(final Void result) {
 189                     // Commited successfully
 190                     s_logger.info( "Install Group -- Committedsuccessfully ") ;
 191                 }
 192
 193                 @Override
 194                 public void onFailure(final Throwable t) {
 195                     // Transaction failed
 196
 197                     if(t instanceof OptimisticLockFailedException) {
 198                         // Failed because of concurrent transaction modifying same data
 199                         s_logger.error( "Install Group -- Failed because of concurrent transaction modifying same data ") ;
 200                     } else {
 201                        // Some other type of TransactionCommitFailedException
 202                         s_logger.error( "Install Group -- Some other type of TransactionCommitFailedException " + t) ;
 203                     }
 204                 }
 205              });
 206            } catch (Exception e) {
 207             s_logger.error("Could not install Group: {}, exception: {}", groupEntity, e.getMessage());
 208             throw e;
 209         }
 210     }
 211
 212     public void removeFlow(FlowEntity flowEntity) {
 213         try {
 214             Node nodeDpn = buildDpnNode(flowEntity.getDpnId());
 215             FlowKey flowKey = new FlowKey(new FlowId(flowEntity.getFlowId()));
 216             InstanceIdentifier<Flow> flowInstanceId = InstanceIdentifier.builder(Nodes.class)
 217                     .child(Node.class, nodeDpn.getKey()).augmentation(FlowCapableNode.class)
 218                     .child(Table.class, new TableKey(flowEntity.getTableId())).child(Flow.class, flowKey).build();
 219
 220
 221                 WriteTransaction modification = m_dataBroker.newWriteOnlyTransaction();
 222                 modification.delete(LogicalDatastoreType.CONFIGURATION,flowInstanceId );
 223
 224                 CheckedFuture<Void,TransactionCommitFailedException> submitFuture  = modification.submit();
 225
 226                 Futures.addCallback(submitFuture, new FutureCallback<Void>() {
 227                     @Override
 228                     public void onSuccess(final Void result) {
 229                         // Commited successfully
 230                         s_logger.info( "Delete Flow -- Committedsuccessfully ") ;
 231                     }
 232
 233                     @Override
 234                     public void onFailure(final Throwable t) {
 235                         // Transaction failed
 236                         if(t instanceof OptimisticLockFailedException) {
 237                             // Failed because of concurrent transaction modifying same data
 238                             s_logger.error( "Delete Flow -- Failed because of concurrent transaction modifying same data ") ;
 239                         } else {
 240                            // Some other type of TransactionCommitFailedException
 241                             s_logger.error( "Delete Flow -- Some other type of TransactionCommitFailedException " + t) ;
 242                         }
 243                     }
 244
 245                 });
 246         } catch (Exception e) {
 247             s_logger.error("Could not remove Flow: {}, exception: {}", flowEntity, e.getMessage());
 248         }
 249     }
 250
 251     public void removeGroup(GroupEntity groupEntity) {
 252         try {
 253             Node nodeDpn = buildDpnNode(groupEntity.getDpnId());
 254             InstanceIdentifier<Group> groupInstanceId = InstanceIdentifier.builder(Nodes.class)
 255                     .child(Node.class, nodeDpn.getKey()).augmentation(FlowCapableNode.class)
 256                     .child(Group.class, new GroupKey(new GroupId(groupEntity.getGroupId()))).build();
 257
 258             WriteTransaction modification = m_dataBroker.newWriteOnlyTransaction();
 259
 260             modification.delete(LogicalDatastoreType.CONFIGURATION,groupInstanceId );
 261
 262             CheckedFuture<Void,TransactionCommitFailedException> submitFuture  = modification.submit();
 263
 264             Futures.addCallback(submitFuture, new FutureCallback<Void>() {
 265                 @Override
 266                 public void onSuccess(final Void result) {
 267                     // Commited successfully
 268                     s_logger.info( "Install Group -- Committedsuccessfully ") ;
 269                 }
 270
 271                 @Override
 272                 public void onFailure(final Throwable t) {
 273                     // Transaction failed
 274                     if(t instanceof OptimisticLockFailedException) {
 275                         // Failed because of concurrent transaction modifying same data
 276                         s_logger.error( "Install Group -- Failed because of concurrent transaction modifying same data ") ;
 277                     } else {
 278                        // Some other type of TransactionCommitFailedException
 279                         s_logger.error( "Install Group -- Some other type of TransactionCommitFailedException " + t) ;
 280                     }
 281                 }
 282             });
 283         } catch (Exception e) {
 284             s_logger.error("Could not remove Group: {}, exception: {}", groupEntity, e.getMessage());
 285         }
 286     }
 287
 288     public void modifyGroup(GroupEntity groupEntity) {
 289
 290         installGroup(groupEntity);
 291     }
 292
 293     private String generateTransactionUri() {
 294         long lTransactionIdOut = m_atomicInteger.incrementAndGet();
 295
 296         // TO DO Introduce this later
 297       //  return "" + (lTransactionIdOut | m_lTransactionIdPrefix);
 298         return "" + (lTransactionIdOut );
 299     }
 300 /*
 301     private String generateTransactionUriForFlow(long nTransactionId) {
 302         long lTransactionIdOut = m_atomicInteger.incrementAndGet();
 303         return Long.toString((lTransactionIdOut | m_lTransactionIdPrefix)) + EUtil.TRANSACTION_ID_SEPARATOR
 304                 + Long.toString(nTransactionId);
 305     }
 306 */
 307
 308     public void sendPacketOut(long lDpnId, int groupId, byte[] payload) {
 309
 310         List<ActionInfo> actionInfos = new ArrayList<ActionInfo>();
 311         actionInfos.add(new ActionInfo(ActionType.group, new String[] { String.valueOf(groupId) }));
 312
 313         sendPacketOutWithActions(lDpnId, groupId, payload, actionInfos);
 314     }
 315
 316     public void sendPacketOutWithActions(long lDpnId, long groupId, byte[] payload, List<ActionInfo> actionInfos) {
 317
 318         m_packetProcessingService.transmitPacket(MDSALUtil.getPacketOut(actionInfos, payload, lDpnId,
 319                 getNodeConnRef("openflow:" + lDpnId, "0xfffffffd")));
 320     }
 321
 322     public void sendARPPacketOutWithActions(long lDpnId, byte[] payload, List<ActionInfo> actions) {
 323         m_packetProcessingService.transmitPacket(MDSALUtil.getPacketOut(actions, payload, lDpnId,
 324                 getNodeConnRef("openflow:" + lDpnId, "0xfffffffd")));
 325     }
 326
 327     private NodeKey getNodeKey(long dpId) {
 328         String nodeId = "openflow:" + dpId;
 329         NodeKey nodeKey = new NodeKey(new NodeId(nodeId));
 330         return nodeKey;
 331     }
 332
 333     public InstanceIdentifier<Node> nodeToInstanceId(Node node) {
 334         return InstanceIdentifier.builder(Nodes.class).child(Node.class, node.getKey()).toInstance();
 335     }
 336
 337     private static NodeConnectorRef getNodeConnRef(final String nodeId, final String port) {
 338         StringBuilder _stringBuilder = new StringBuilder(nodeId);
 339         StringBuilder _append = _stringBuilder.append(":");
 340         StringBuilder sBuild = _append.append(port);
 341         String _string = sBuild.toString();
 342         NodeConnectorId _nodeConnectorId = new NodeConnectorId(_string);
 343         NodeConnectorKey _nodeConnectorKey = new NodeConnectorKey(_nodeConnectorId);
 344         NodeConnectorKey nConKey = _nodeConnectorKey;
 345         InstanceIdentifierBuilder<Nodes> _builder = InstanceIdentifier.<Nodes> builder(Nodes.class);
 346         NodeId _nodeId = new NodeId(nodeId);
 347         NodeKey _nodeKey = new NodeKey(_nodeId);
 348         InstanceIdentifierBuilder<Node> _child = _builder.<Node, NodeKey> child(Node.class, _nodeKey);
 349         InstanceIdentifierBuilder<NodeConnector> _child_1 = _child.<NodeConnector, NodeConnectorKey> child(
 350                 NodeConnector.class, nConKey);
 351         InstanceIdentifier<NodeConnector> path = _child_1.toInstance();
 352         NodeConnectorRef _nodeConnectorRef = new NodeConnectorRef(path);
 353         return _nodeConnectorRef;
 354     }
 355
 356     private long getDpnIdFromNodeName(String nodeName) {
 357         String dpId = nodeName.substring(nodeName.lastIndexOf(":") + 1);
 358         return Long.parseLong(dpId);
 359     }
 360
 361     private Node buildDpnNode(long lDpnId) {
 362         NodeId nodeId = new NodeId("openflow:" + lDpnId);
 363         Node nodeDpn = new NodeBuilder().setId(nodeId).setKey(new NodeKey(nodeId)).build();
 364
 365         return nodeDpn;
 366     }
 367
 368 }