nemo-renderers/openflow-renderer/src/main/java/org/opendaylight/nemo/renderer/openflow/physicalnetwork/DataBrokerAdapter.java

   1 /*
   2  * Copyright (c) 2015 Huawei, 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.nemo.renderer.openflow.physicalnetwork;
  10
  11 import com.google.common.util.concurrent.CheckedFuture;
  12 import com.google.common.util.concurrent.FutureCallback;
  13 import com.google.common.util.concurrent.Futures;
  14 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  15 import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
  16 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  17 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.PhysicalNetwork;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.PhysicalHosts;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.PhysicalLinks;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.PhysicalNodes;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.hosts.PhysicalHost;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.hosts.PhysicalHostKey;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.links.PhysicalLink;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.links.PhysicalLinkKey;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.nodes.PhysicalNode;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.nodes.PhysicalNodeKey;
  28 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  29 import org.slf4j.Logger;
  30 import org.slf4j.LoggerFactory;
  31
  32 /**
  33 * Created by hj on 11/6/15.
  34 */
  35 public class DataBrokerAdapter {
  36     private static final Logger log = LoggerFactory.getLogger(DataBrokerAdapter.class);
  37     final private DataBroker dataBroker;
  38     private static final String DEFAULT_TOPOLOGY_ID = "flow:1";
  39
  40
  41     public DataBrokerAdapter(DataBroker dataBroker) {
  42         this.dataBroker = dataBroker;
  43     }
  44
  45
  46
  47     private InstanceIdentifier<PhysicalHost> getPhysicalHostIdentifier(PhysicalHostKey physicalHostKey) {
  48         return InstanceIdentifier
  49                 .builder(PhysicalNetwork.class)
  50                 .child(PhysicalHosts.class)
  51                 .child(PhysicalHost.class, physicalHostKey)
  52                 .build();
  53     }
  54     private InstanceIdentifier<PhysicalNode> getPhysicalNodeIdentifier(PhysicalNodeKey physicalNodeKey) {
  55         return InstanceIdentifier
  56                 .builder(PhysicalNetwork.class)
  57                 .child(PhysicalNodes.class)
  58                 .child(PhysicalNode.class, physicalNodeKey)
  59                 .build();
  60     }
  61     private InstanceIdentifier<PhysicalLink> getPhysicalLinkIdentifier(PhysicalLinkKey physicalLinkKey) {
  62         return InstanceIdentifier
  63                 .builder(PhysicalNetwork.class)
  64                 .child(PhysicalLinks.class)
  65                 .child(PhysicalLink.class, physicalLinkKey)
  66                 .build();
  67     }
  68
  69     protected void addPhysicalHost(final PhysicalHost physicalHost) {
  70         try {
  71             WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
  72             final InstanceIdentifier<PhysicalHost> instanceIdentifier = getPhysicalHostIdentifier(physicalHost.getKey());
  73
  74             transaction.put(LogicalDatastoreType.OPERATIONAL, instanceIdentifier, physicalHost, true);
  75
  76             CheckedFuture<Void, TransactionCommitFailedException> future = transaction.submit();
  77             Futures.addCallback(future, new FutureCallback<Void>() {
  78                 @Override
  79                 public void onFailure(Throwable t) {
  80                     log.warn("Could not write PhysicalHost: {}  {}", physicalHost, t);
  81                 }
  82
  83                 @Override
  84                 public void onSuccess(Void result) {
  85                     //System.out.println("write transaction onSuccess.");
  86                     log.debug("Write PhysicalHost transaction onSuccess: {}.", physicalHost);
  87                 }
  88             });
  89
  90         } catch (Exception e) {
  91             e.printStackTrace();
  92         }
  93
  94     }
  95     protected boolean addPhysicalNode(final PhysicalNode physicalNode){
  96         final boolean[] addResult = {false};
  97         try {
  98             WriteTransaction t = dataBroker.newWriteOnlyTransaction();
  99             InstanceIdentifier<PhysicalNode> identifier = getPhysicalNodeIdentifier(physicalNode.getKey());
 100             t.put(LogicalDatastoreType.OPERATIONAL, identifier, physicalNode, true);
 101
 102             CheckedFuture<Void, TransactionCommitFailedException> future = t.submit();
 103             Futures.addCallback(future, new FutureCallback<Void>() {
 104                 @Override
 105                 public void onFailure(Throwable t) {
 106                     log.warn("Could not write PhysicalNode {} : {}",physicalNode, t);
 107                 }
 108
 109                 @Override
 110                 public void onSuccess(Void result) {
 111                     addResult[0] = true;
 112                     log.debug("write transaction onSuccess.");
 113                 }
 114             });
 115
 116         } catch (Exception e) {
 117             e.printStackTrace();
 118         }
 119         return addResult[0];
 120     }
 121     protected boolean removePhysicalNode(final PhysicalNodeKey nodeKey){
 122         final boolean[] removeResult = {false};
 123         try {
 124             WriteTransaction t = dataBroker.newWriteOnlyTransaction();
 125             InstanceIdentifier<PhysicalNode> identifier = getPhysicalNodeIdentifier(nodeKey);
 126             t.delete(LogicalDatastoreType.OPERATIONAL, identifier);
 127
 128             CheckedFuture<Void, TransactionCommitFailedException> future = t.submit();
 129             Futures.addCallback(future, new FutureCallback<Void>() {
 130                 @Override
 131                 public void onFailure(Throwable t) {
 132                     log.error("Could not delete PhysicalNode {} : {}",nodeKey, t);
 133                 }
 134
 135                 @Override
 136                 public void onSuccess(Void result) {
 137                     removeResult[0]=true;
 138                     log.debug("Delete {} transaction onSuccess.",nodeKey);
 139                 }
 140             });
 141
 142         } catch (Exception e) {
 143             e.printStackTrace();
 144         }
 145         return removeResult[0];
 146     }
 147
 148     protected void addPhysicalLink(final PhysicalLink physicalLink){
 149         try {
 150             WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 151             final InstanceIdentifier<PhysicalLink> linkIdentifier = getPhysicalLinkIdentifier(physicalLink.getKey());
 152             transaction.put(LogicalDatastoreType.OPERATIONAL, linkIdentifier, physicalLink, true);
 153
 154             CheckedFuture<Void, TransactionCommitFailedException> f = transaction.submit();
 155             Futures.addCallback(f, new FutureCallback<Void>() {
 156                 @Override
 157                 public void onFailure(Throwable t) {
 158                     log.warn("Could not put PhysicalLink {} : {}",physicalLink.getKey(), t);
 159                 }
 160
 161                 @Override
 162                 public void onSuccess(Void result) {
 163                     //System.out.println("write transaction onSuccess.");
 164                     log.debug("Put transaction onSuccess:{}.",physicalLink.getKey());
 165                 }
 166             });
 167
 168         } catch (Exception e) {
 169             e.printStackTrace();
 170         }
 171     }
 172     protected void removePhysicalLink(final PhysicalLinkKey physicalLinkKey){
 173         try {
 174             WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 175             final InstanceIdentifier<PhysicalLink> linkIdentifier = getPhysicalLinkIdentifier(physicalLinkKey);
 176             transaction.delete(LogicalDatastoreType.OPERATIONAL, linkIdentifier);
 177
 178             CheckedFuture<Void, TransactionCommitFailedException> f = transaction.submit();
 179             Futures.addCallback(f, new FutureCallback<Void>() {
 180                 @Override
 181                 public void onFailure(Throwable t) {
 182                     log.warn("Could not remove PhysicalLink {} : {}",physicalLinkKey, t);
 183                 }
 184
 185                 @Override
 186                 public void onSuccess(Void result) {
 187                     //System.out.println("write transaction onSuccess.");
 188                     log.debug("Remove transaction onSuccess:{}.", physicalLinkKey);
 189                 }
 190             });
 191
 192         } catch (Exception e) {
 193             e.printStackTrace();
 194         }
 195     }
 196
 197 }