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