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

   1 /*
   2  * Copyright (c) 2015 Ericsson India Global Services Pvt Ltd. 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.vpnservice.mdsalutil.internal;
  10
  11 import java.math.BigInteger;
  12 import java.util.ArrayList;
  13 import java.util.List;
  14 import org.opendaylight.vpnservice.mdsalutil.ActionInfo;
  15 import org.opendaylight.vpnservice.mdsalutil.ActionType;
  16 import org.opendaylight.vpnservice.mdsalutil.FlowEntity;
  17 import org.opendaylight.vpnservice.mdsalutil.GroupEntity;
  18 import org.opendaylight.vpnservice.mdsalutil.MDSALUtil;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowId;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowBuilder;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.FlowKey;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.GroupId;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.GroupKey;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.packet.service.rev130709.PacketProcessingService;
  39 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  40 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.InstanceIdentifierBuilder;
  41 import org.slf4j.Logger;
  42 import org.slf4j.LoggerFactory;
  43 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  44 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  45 import org.opendaylight.controller.md.sal.common.api.data.OptimisticLockFailedException;
  46 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  47 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  48
  49 import com.google.common.util.concurrent.CheckedFuture;
  50 import com.google.common.util.concurrent.FutureCallback;
  51 import com.google.common.util.concurrent.Futures;
  52
  53 public class MDSALManager implements AutoCloseable {
  54
  55     private static final Logger s_logger = LoggerFactory.getLogger(MDSALManager.class);
  56
  57     private DataBroker m_dataBroker;
  58
  59     private PacketProcessingService m_packetProcessingService;
  60
  61     /**
  62      * Writes the flows and Groups to the MD SAL DataStore
  63      * which will be sent to the openflowplugin for installing flows/groups on the switch.
  64      * Other modules of VPN service that wants to install flows / groups on the switch
  65      * uses this utility
  66      *
  67      * @param db - dataBroker reference
  68      * @param pktProcService- PacketProcessingService for sending the packet outs
  69      */
  70     public MDSALManager(final DataBroker db, PacketProcessingService pktProcService) {
  71         m_dataBroker = db;
  72         m_packetProcessingService = pktProcService;
  73         s_logger.info( "MDSAL Manager Initialized ") ;
  74     }
  75
  76     @Override
  77     public void close() throws Exception {
  78         s_logger.info("MDSAL Manager Closed");
  79     }
  80
  81     public void installFlow(FlowEntity flowEntity) {
  82
  83         try {
  84             s_logger.trace("InstallFlow for flowEntity {} ", flowEntity);
  85
  86             if (flowEntity.getCookie() == null) {
  87                flowEntity.setCookie(new BigInteger("0110000", 16));
  88             }
  89
  90             FlowKey flowKey = new FlowKey( new FlowId(flowEntity.getFlowId()) );
  91
  92             FlowBuilder flowbld = flowEntity.getFlowBuilder();
  93
  94             Node nodeDpn = buildDpnNode(flowEntity.getDpnId());
  95             InstanceIdentifier<Flow> flowInstanceId = InstanceIdentifier.builder(Nodes.class)
  96                     .child(Node.class, nodeDpn.getKey()).augmentation(FlowCapableNode.class)
  97                     .child(Table.class, new TableKey(flowEntity.getTableId())).child(Flow.class,flowKey).build();
  98
  99             WriteTransaction modification = m_dataBroker.newWriteOnlyTransaction();
 100
 101             modification.put(LogicalDatastoreType.CONFIGURATION, flowInstanceId, flowbld.build(),true );
 102
 103             CheckedFuture<Void,TransactionCommitFailedException> submitFuture  = modification.submit();
 104
 105             Futures.addCallback(submitFuture, new FutureCallback<Void>() {
 106
 107                 @Override
 108                 public void onSuccess(final Void result) {
 109                     // Commited successfully
 110                     s_logger.debug( "Install Flow -- Committedsuccessfully ") ;
 111                 }
 112
 113                 @Override
 114                 public void onFailure(final Throwable t) {
 115                     // Transaction failed
 116
 117                     if(t instanceof OptimisticLockFailedException) {
 118                         // Failed because of concurrent transaction modifying same data
 119                         s_logger.error( "Install Flow -- Failed because of concurrent transaction modifying same data ") ;
 120                     } else {
 121                        // Some other type of TransactionCommitFailedException
 122                         s_logger.error( "Install Flow -- Some other type of TransactionCommitFailedException " + t) ;
 123                     }
 124                 }
 125             });
 126         } catch (Exception e) {
 127             s_logger.error("Could not install flow: {}, exception: {}", flowEntity, e);
 128         }
 129     }
 130
 131     public void installGroup(GroupEntity groupEntity) {
 132         try {
 133             Group group = groupEntity.getGroupBuilder().build();
 134
 135             Node nodeDpn = buildDpnNode(groupEntity.getDpnId());
 136
 137             InstanceIdentifier<Group> groupInstanceId = InstanceIdentifier.builder(Nodes.class)
 138                     .child(Node.class, nodeDpn.getKey()).augmentation(FlowCapableNode.class)
 139                     .child(Group.class, new GroupKey(new GroupId(groupEntity.getGroupId()))).build();
 140
 141             WriteTransaction modification = m_dataBroker.newWriteOnlyTransaction();
 142
 143             modification.put(LogicalDatastoreType.CONFIGURATION, groupInstanceId, group, true);
 144
 145             CheckedFuture<Void,TransactionCommitFailedException> submitFuture  = modification.submit();
 146
 147             Futures.addCallback(submitFuture, new FutureCallback<Void>() {
 148                 @Override
 149                 public void onSuccess(final Void result) {
 150                     // Commited successfully
 151                     s_logger.debug( "Install Group -- Committedsuccessfully ") ;
 152                 }
 153
 154                 @Override
 155                 public void onFailure(final Throwable t) {
 156                     // Transaction failed
 157
 158                     if(t instanceof OptimisticLockFailedException) {
 159                         // Failed because of concurrent transaction modifying same data
 160                         s_logger.error( "Install Group -- Failed because of concurrent transaction modifying same data ") ;
 161                     } else {
 162                        // Some other type of TransactionCommitFailedException
 163                         s_logger.error( "Install Group -- Some other type of TransactionCommitFailedException " + t) ;
 164                     }
 165                 }
 166              });
 167            } catch (Exception e) {
 168             s_logger.error("Could not install Group: {}, exception: {}", groupEntity, e);
 169             throw e;
 170         }
 171     }
 172
 173     public void removeFlow(FlowEntity flowEntity) {
 174         try {
 175             Node nodeDpn = buildDpnNode(flowEntity.getDpnId());
 176             FlowKey flowKey = new FlowKey(new FlowId(flowEntity.getFlowId()));
 177             InstanceIdentifier<Flow> flowInstanceId = InstanceIdentifier.builder(Nodes.class)
 178                     .child(Node.class, nodeDpn.getKey()).augmentation(FlowCapableNode.class)
 179                     .child(Table.class, new TableKey(flowEntity.getTableId())).child(Flow.class, flowKey).build();
 180
 181
 182                 WriteTransaction modification = m_dataBroker.newWriteOnlyTransaction();
 183                 modification.delete(LogicalDatastoreType.CONFIGURATION,flowInstanceId );
 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.debug( "Delete Flow -- Committedsuccessfully ") ;
 192                     }
 193
 194                     @Override
 195                     public void onFailure(final Throwable t) {
 196                         // Transaction failed
 197                         if(t instanceof OptimisticLockFailedException) {
 198                             // Failed because of concurrent transaction modifying same data
 199                             s_logger.error( "Delete Flow -- Failed because of concurrent transaction modifying same data ") ;
 200                         } else {
 201                            // Some other type of TransactionCommitFailedException
 202                             s_logger.error( "Delete Flow -- Some other type of TransactionCommitFailedException " + t) ;
 203                         }
 204                     }
 205
 206                 });
 207         } catch (Exception e) {
 208             s_logger.error("Could not remove Flow: {}, exception: {}", flowEntity, e);
 209         }
 210     }
 211
 212     public void removeGroup(GroupEntity groupEntity) {
 213         try {
 214             Node nodeDpn = buildDpnNode(groupEntity.getDpnId());
 215             InstanceIdentifier<Group> groupInstanceId = InstanceIdentifier.builder(Nodes.class)
 216                     .child(Node.class, nodeDpn.getKey()).augmentation(FlowCapableNode.class)
 217                     .child(Group.class, new GroupKey(new GroupId(groupEntity.getGroupId()))).build();
 218
 219             WriteTransaction modification = m_dataBroker.newWriteOnlyTransaction();
 220
 221             modification.delete(LogicalDatastoreType.CONFIGURATION,groupInstanceId );
 222
 223             CheckedFuture<Void,TransactionCommitFailedException> submitFuture  = modification.submit();
 224
 225             Futures.addCallback(submitFuture, new FutureCallback<Void>() {
 226                 @Override
 227                 public void onSuccess(final Void result) {
 228                     // Commited successfully
 229                     s_logger.debug( "Install Group -- Committedsuccessfully ") ;
 230                 }
 231
 232                 @Override
 233                 public void onFailure(final Throwable t) {
 234                     // Transaction failed
 235                     if(t instanceof OptimisticLockFailedException) {
 236                         // Failed because of concurrent transaction modifying same data
 237                         s_logger.error( "Install Group -- Failed because of concurrent transaction modifying same data ") ;
 238                     } else {
 239                        // Some other type of TransactionCommitFailedException
 240                         s_logger.error( "Install Group -- Some other type of TransactionCommitFailedException " + t) ;
 241                     }
 242                 }
 243             });
 244         } catch (Exception e) {
 245             s_logger.error("Could not remove Group: {}, exception: {}", groupEntity, e);
 246         }
 247     }
 248
 249     public void modifyGroup(GroupEntity groupEntity) {
 250
 251         installGroup(groupEntity);
 252     }
 253
 254     public void sendPacketOut(long lDpnId, int groupId, byte[] payload) {
 255
 256         List<ActionInfo> actionInfos = new ArrayList<ActionInfo>();
 257         actionInfos.add(new ActionInfo(ActionType.group, new String[] { String.valueOf(groupId) }));
 258
 259         sendPacketOutWithActions(lDpnId, groupId, payload, actionInfos);
 260     }
 261
 262     public void sendPacketOutWithActions(long lDpnId, long groupId, byte[] payload, List<ActionInfo> actionInfos) {
 263
 264         m_packetProcessingService.transmitPacket(MDSALUtil.getPacketOut(actionInfos, payload, lDpnId,
 265                 getNodeConnRef("openflow:" + lDpnId, "0xfffffffd")));
 266     }
 267
 268     public void sendARPPacketOutWithActions(long lDpnId, byte[] payload, List<ActionInfo> actions) {
 269         m_packetProcessingService.transmitPacket(MDSALUtil.getPacketOut(actions, payload, lDpnId,
 270                 getNodeConnRef("openflow:" + lDpnId, "0xfffffffd")));
 271     }
 272
 273     public InstanceIdentifier<Node> nodeToInstanceId(Node node) {
 274         return InstanceIdentifier.builder(Nodes.class).child(Node.class, node.getKey()).toInstance();
 275     }
 276
 277     private static NodeConnectorRef getNodeConnRef(final String nodeId, final String port) {
 278         StringBuilder _stringBuilder = new StringBuilder(nodeId);
 279         StringBuilder _append = _stringBuilder.append(":");
 280         StringBuilder sBuild = _append.append(port);
 281         String _string = sBuild.toString();
 282         NodeConnectorId _nodeConnectorId = new NodeConnectorId(_string);
 283         NodeConnectorKey _nodeConnectorKey = new NodeConnectorKey(_nodeConnectorId);
 284         NodeConnectorKey nConKey = _nodeConnectorKey;
 285         InstanceIdentifierBuilder<Nodes> _builder = InstanceIdentifier.<Nodes> builder(Nodes.class);
 286         NodeId _nodeId = new NodeId(nodeId);
 287         NodeKey _nodeKey = new NodeKey(_nodeId);
 288         InstanceIdentifierBuilder<Node> _child = _builder.<Node, NodeKey> child(Node.class, _nodeKey);
 289         InstanceIdentifierBuilder<NodeConnector> _child_1 = _child.<NodeConnector, NodeConnectorKey> child(
 290                 NodeConnector.class, nConKey);
 291         InstanceIdentifier<NodeConnector> path = _child_1.toInstance();
 292         NodeConnectorRef _nodeConnectorRef = new NodeConnectorRef(path);
 293         return _nodeConnectorRef;
 294     }
 295
 296     private Node buildDpnNode(long lDpnId) {
 297         NodeId nodeId = new NodeId("openflow:" + lDpnId);
 298         Node nodeDpn = new NodeBuilder().setId(nodeId).setKey(new NodeKey(nodeId)).build();
 299
 300         return nodeDpn;
 301     }
 302
 303 }