sfc/translator/src/main/java/org/opendaylight/netvirt/sfc/translator/SfcMdsalHelper.java

   1 /*
   2  * Copyright (c) 2016, 2017 Brocade Communications 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.netvirt.sfc.translator;
  10
  11 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  12 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  13 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  14 import org.opendaylight.genius.datastoreutils.SingleTransactionDataBroker;
  15 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sf.rev140701.ServiceFunctions;
  16 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sf.rev140701.service.functions.ServiceFunction;
  17 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sf.rev140701.service.functions.ServiceFunctionKey;
  18 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfc.rev140701.ServiceFunctionChains;
  19 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfc.rev140701.service.function.chain.grouping.ServiceFunctionChain;
  20 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfc.rev140701.service.function.chain.grouping.ServiceFunctionChainKey;
  21 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.rev140701.ServiceFunctionForwarders;
  22 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.rev140701.service.function.forwarders.ServiceFunctionForwarder;
  23 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sff.rev140701.service.function.forwarders.ServiceFunctionForwarderKey;
  24 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfp.rev140701.ServiceFunctionPaths;
  25 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfp.rev140701.service.function.paths.ServiceFunctionPath;
  26 import org.opendaylight.yang.gen.v1.urn.cisco.params.xml.ns.yang.sfc.sfp.rev140701.service.function.paths.ServiceFunctionPathKey;
  27 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.AccessLists;
  28 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.Acl;
  29 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.access.control.list.rev160218.access.lists.AclKey;
  30 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  31 import org.slf4j.Logger;
  32 import org.slf4j.LoggerFactory;
  33
  34 /**
  35  * Utility methods to read OpenDaylight SFC models.
  36  */
  37 public class SfcMdsalHelper {
  38     private static final Logger LOG = LoggerFactory.getLogger(SfcMdsalHelper.class);
  39     private static final InstanceIdentifier<AccessLists> ACCESS_LIST_IID = InstanceIdentifier.create(AccessLists.class);
  40     private static final InstanceIdentifier<ServiceFunctions> SF_IID =
  41             InstanceIdentifier.create(ServiceFunctions.class);
  42     private static final InstanceIdentifier<ServiceFunctionForwarders> SFF_IID =
  43             InstanceIdentifier.create(ServiceFunctionForwarders.class);
  44     private static final InstanceIdentifier<ServiceFunctionChains> SFC_IID =
  45             InstanceIdentifier.create(ServiceFunctionChains.class);
  46     private static final InstanceIdentifier<ServiceFunctionPaths> SFP_IID
  47             = InstanceIdentifier.create(ServiceFunctionPaths.class);
  48     public static final String NETVIRT_LOGICAL_SFF_NAME = "Netvirt-Logical-SFF";
  49
  50     private final DataBroker dataBroker;
  51
  52     public SfcMdsalHelper(DataBroker dataBroker) {
  53         this.dataBroker = dataBroker;
  54     }
  55
  56     //ACL Flow Classifier data store utility methods
  57     public void addAclFlowClassifier(Acl aclFlowClassifier) {
  58         InstanceIdentifier<Acl> aclIid = getAclPath(aclFlowClassifier.key());
  59         LOG.info("Write ACL FlowClassifier {} to config data store at {}",aclFlowClassifier, aclIid);
  60         try {
  61             SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, aclIid,
  62                     aclFlowClassifier);
  63         } catch (TransactionCommitFailedException e) {
  64             LOG.error("Error writing {} to {}", aclFlowClassifier, aclIid, e);
  65         }
  66     }
  67
  68     public void updateAclFlowClassifier(Acl aclFlowClassifier) {
  69         InstanceIdentifier<Acl> aclIid = getAclPath(aclFlowClassifier.key());
  70         LOG.info("Update ACL FlowClassifier {} in config data store at {}",aclFlowClassifier, aclIid);
  71         try {
  72             SingleTransactionDataBroker.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, aclIid,
  73                     aclFlowClassifier);
  74         } catch (TransactionCommitFailedException e) {
  75             LOG.warn("Failed to merge {}", aclIid, e);
  76         }
  77     }
  78
  79     public void removeAclFlowClassifier(Acl aclFlowClassifier) {
  80         InstanceIdentifier<Acl> aclIid = getAclPath(aclFlowClassifier.key());
  81         LOG.info("Remove ACL FlowClassifier {} from config data store at {}",aclFlowClassifier, aclIid);
  82         try {
  83             SingleTransactionDataBroker.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, aclIid);
  84         } catch (TransactionCommitFailedException e) {
  85             LOG.warn("Failed to delete {}", aclIid, e);
  86         }
  87     }
  88
  89     //Service Function
  90     public ServiceFunction readServiceFunction(ServiceFunctionKey sfKey) {
  91         InstanceIdentifier<ServiceFunction> sfIid = getSFPath(sfKey);
  92         LOG.info("Read Service Function {} from config data store at {}",sfKey, sfIid);
  93         return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
  94                 LogicalDatastoreType.CONFIGURATION, sfIid).orNull();
  95     }
  96
  97     public void addServiceFunction(ServiceFunction sf) {
  98         InstanceIdentifier<ServiceFunction> sfIid = getSFPath(sf.key());
  99         LOG.info("Write Service Function {} to config data store at {}",sf, sfIid);
 100         try {
 101             SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, sfIid, sf);
 102         } catch (TransactionCommitFailedException e) {
 103             LOG.error("Error writing {} to {}", sf, sfIid, e);
 104         }
 105     }
 106
 107     public void updateServiceFunction(ServiceFunction sf) {
 108         InstanceIdentifier<ServiceFunction> sfIid = getSFPath(sf.key());
 109         LOG.info("Update Service Function {} in config data store at {}",sf, sfIid);
 110         try {
 111             SingleTransactionDataBroker.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, sfIid, sf);
 112         } catch (TransactionCommitFailedException e) {
 113             LOG.warn("Failed to merge {}", sfIid, e);
 114         }
 115     }
 116
 117     public void removeServiceFunction(ServiceFunctionKey sfKey) {
 118         InstanceIdentifier<ServiceFunction> sfIid = getSFPath(sfKey);
 119         LOG.info("Remove Service Function {} from config data store at {}",sfKey, sfIid);
 120         try {
 121             SingleTransactionDataBroker.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, sfIid);
 122         } catch (TransactionCommitFailedException e) {
 123             LOG.warn("Failed to delete {}", sfIid, e);
 124         }
 125     }
 126
 127     //Service Function Forwarder
 128     public ServiceFunctionForwarder readServiceFunctionForwarder(ServiceFunctionForwarderKey sffKey) {
 129         InstanceIdentifier<ServiceFunctionForwarder> sffIid = getSFFPath(sffKey);
 130         LOG.info("Read Service Function Forwarder from config data store at {}", sffIid);
 131         return SingleTransactionDataBroker.syncReadOptionalAndTreatReadFailedExceptionAsAbsentOptional(dataBroker,
 132                 LogicalDatastoreType.CONFIGURATION, sffIid).orNull();
 133     }
 134
 135     public void addServiceFunctionForwarder(ServiceFunctionForwarder sff) {
 136         InstanceIdentifier<ServiceFunctionForwarder> sffIid = getSFFPath(sff.key());
 137         LOG.info("Write Service Function Forwarder {} to config data store at {}",sff, sffIid);
 138         try {
 139             SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, sffIid, sff);
 140         } catch (TransactionCommitFailedException e) {
 141             LOG.error("Error writing {} to {}", sff, sffIid, e);
 142         }
 143     }
 144
 145     public void updateServiceFunctionForwarder(ServiceFunctionForwarder sff) {
 146         InstanceIdentifier<ServiceFunctionForwarder> sffIid = getSFFPath(sff.key());
 147         LOG.info("Update Service Function Forwarder {} to config data store at {}",sff, sffIid);
 148         try {
 149             SingleTransactionDataBroker.syncUpdate(dataBroker, LogicalDatastoreType.CONFIGURATION, sffIid, sff);
 150         } catch (TransactionCommitFailedException e) {
 151             LOG.error("Error writing {} to {}", sff, sffIid, e);
 152         }
 153     }
 154
 155     public void deleteServiceFunctionForwarder(ServiceFunctionForwarderKey sffKey) {
 156         InstanceIdentifier<ServiceFunctionForwarder> sffIid = getSFFPath(sffKey);
 157         LOG.info("Delete Service Function Forwarder from config data store at {}", sffIid);
 158         try {
 159             SingleTransactionDataBroker.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, sffIid);
 160         } catch (TransactionCommitFailedException e) {
 161             LOG.warn("Failed to delete {}", sffIid, e);
 162         }
 163     }
 164
 165     public void addServiceFunctionChain(ServiceFunctionChain sfc) {
 166         InstanceIdentifier<ServiceFunctionChain> sfcIid = getSFCPath(sfc.key());
 167         LOG.info("Write Service Function Chain {} to config data store at {}",sfc, sfcIid);
 168         try {
 169             SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, sfcIid, sfc);
 170         } catch (TransactionCommitFailedException e) {
 171             LOG.error("Error writing {} to {}", sfc, sfcIid, e);
 172         }
 173     }
 174
 175     public void deleteServiceFunctionChain(ServiceFunctionChainKey sfcKey) {
 176         InstanceIdentifier<ServiceFunctionChain> sfcIid = getSFCPath(sfcKey);
 177         LOG.info("Remove Service Function Chain {} from config data store at {}",sfcKey, sfcIid);
 178         try {
 179             SingleTransactionDataBroker.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, sfcIid);
 180         } catch (TransactionCommitFailedException e) {
 181             LOG.warn("Failed to delete {}", sfcIid, e);
 182         }
 183     }
 184
 185     public void addServiceFunctionPath(ServiceFunctionPath sfp) {
 186         InstanceIdentifier<ServiceFunctionPath> sfpIid = getSFPPath(sfp.key());
 187         LOG.info("Write Service Function Path {} to config data store at {}",sfp, sfpIid);
 188         try {
 189             SingleTransactionDataBroker.syncWrite(dataBroker, LogicalDatastoreType.CONFIGURATION, sfpIid, sfp);
 190         } catch (TransactionCommitFailedException e) {
 191             LOG.error("Error writing {} to {}", sfp, sfpIid, e);
 192         }
 193     }
 194
 195     public void deleteServiceFunctionPath(ServiceFunctionPathKey sfpKey) {
 196         InstanceIdentifier<ServiceFunctionPath> sfpIid = getSFPPath(sfpKey);
 197         LOG.info("Delete Service Function Path from config data store at {}", sfpIid);
 198         try {
 199             SingleTransactionDataBroker.syncDelete(dataBroker, LogicalDatastoreType.CONFIGURATION, sfpIid);
 200         } catch (TransactionCommitFailedException e) {
 201             LOG.warn("Failed to delete {}", sfpIid, e);
 202         }
 203     }
 204
 205     private static InstanceIdentifier<Acl> getAclPath(AclKey aclKey) {
 206         return ACCESS_LIST_IID.builder().child(Acl.class, aclKey).build();
 207     }
 208
 209     private static InstanceIdentifier<ServiceFunction> getSFPath(ServiceFunctionKey key) {
 210         return SF_IID.builder().child(ServiceFunction.class, key).build();
 211     }
 212
 213     private static InstanceIdentifier<ServiceFunctionForwarder> getSFFPath(ServiceFunctionForwarderKey key) {
 214         return SFF_IID.builder().child(ServiceFunctionForwarder.class, key).build();
 215     }
 216
 217     private static InstanceIdentifier<ServiceFunctionChain> getSFCPath(ServiceFunctionChainKey key) {
 218         return SFC_IID.builder().child(ServiceFunctionChain.class, key).build();
 219     }
 220
 221     private static InstanceIdentifier<ServiceFunctionPath> getSFPPath(ServiceFunctionPathKey key) {
 222         return SFP_IID.builder().child(ServiceFunctionPath.class, key).build();
 223     }
 224 }