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             // TODO Auto-generated catch block
  92             log.error("Exception:",e);
  93         }
  94
  95     }
  96     protected boolean addPhysicalNode(final PhysicalNode physicalNode){
  97         final boolean[] addResult = {false};
  98         try {
  99             WriteTransaction t = dataBroker.newWriteOnlyTransaction();
 100             InstanceIdentifier<PhysicalNode> identifier = getPhysicalNodeIdentifier(physicalNode.getKey());
 101             t.put(LogicalDatastoreType.OPERATIONAL, identifier, physicalNode, true);
 102
 103             CheckedFuture<Void, TransactionCommitFailedException> future = t.submit();
 104             Futures.addCallback(future, new FutureCallback<Void>() {
 105                 @Override
 106                 public void onFailure(Throwable t) {
 107                     log.warn("Could not write PhysicalNode {} : {}",physicalNode, t);
 108                 }
 109
 110                 @Override
 111                 public void onSuccess(Void result) {
 112                     addResult[0] = true;
 113                     log.debug("write transaction onSuccess.");
 114                 }
 115             });
 116
 117         } catch (Exception e) {
 118             // TODO Auto-generated catch block
 119             log.error("Exception:",e);
 120         }
 121         return addResult[0];
 122     }
 123     protected boolean removePhysicalNode(final PhysicalNodeKey nodeKey){
 124         final boolean[] removeResult = {false};
 125         try {
 126             WriteTransaction t = dataBroker.newWriteOnlyTransaction();
 127             InstanceIdentifier<PhysicalNode> identifier = getPhysicalNodeIdentifier(nodeKey);
 128             t.delete(LogicalDatastoreType.OPERATIONAL, identifier);
 129
 130             CheckedFuture<Void, TransactionCommitFailedException> future = t.submit();
 131             Futures.addCallback(future, new FutureCallback<Void>() {
 132                 @Override
 133                 public void onFailure(Throwable t) {
 134                     log.error("Could not delete PhysicalNode {} : {}",nodeKey, t);
 135                 }
 136
 137                 @Override
 138                 public void onSuccess(Void result) {
 139                     removeResult[0]=true;
 140                     log.debug("Delete {} transaction onSuccess.",nodeKey);
 141                 }
 142             });
 143
 144         } catch (Exception e) {
 145             // TODO Auto-generated catch block
 146             log.error("Exception:",e);
 147         }
 148         return removeResult[0];
 149     }
 150
 151     protected void addPhysicalLink(final PhysicalLink physicalLink){
 152         try {
 153             WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 154             final InstanceIdentifier<PhysicalLink> linkIdentifier = getPhysicalLinkIdentifier(physicalLink.getKey());
 155             transaction.put(LogicalDatastoreType.OPERATIONAL, linkIdentifier, physicalLink, true);
 156
 157             CheckedFuture<Void, TransactionCommitFailedException> f = transaction.submit();
 158             Futures.addCallback(f, new FutureCallback<Void>() {
 159                 @Override
 160                 public void onFailure(Throwable t) {
 161                     log.warn("Could not put PhysicalLink {} : {}",physicalLink.getKey(), t);
 162                 }
 163
 164                 @Override
 165                 public void onSuccess(Void result) {
 166                     //System.out.println("write transaction onSuccess.");
 167                     log.debug("Put transaction onSuccess:{}.",physicalLink.getKey());
 168                 }
 169             });
 170
 171         } catch (Exception e) {
 172             // TODO Auto-generated catch block
 173             log.error("Exception:",e);
 174         }
 175     }
 176     protected void removePhysicalLink(final PhysicalLinkKey physicalLinkKey){
 177         try {
 178             WriteTransaction transaction = dataBroker.newWriteOnlyTransaction();
 179             final InstanceIdentifier<PhysicalLink> linkIdentifier = getPhysicalLinkIdentifier(physicalLinkKey);
 180             transaction.delete(LogicalDatastoreType.OPERATIONAL, linkIdentifier);
 181
 182             CheckedFuture<Void, TransactionCommitFailedException> f = transaction.submit();
 183             Futures.addCallback(f, new FutureCallback<Void>() {
 184                 @Override
 185                 public void onFailure(Throwable t) {
 186                     log.warn("Could not remove PhysicalLink {} : {}",physicalLinkKey, t);
 187                 }
 188
 189                 @Override
 190                 public void onSuccess(Void result) {
 191                     //System.out.println("write transaction onSuccess.");
 192                     log.debug("Remove transaction onSuccess:{}.", physicalLinkKey);
 193                 }
 194             });
 195
 196         } catch (Exception e) {
 197             // TODO Auto-generated catch block
 198             log.error("Exception:",e);
 199         }
 200     }
 201
 202 }