opendaylight/md-sal/sal-rest-connector/src/main/java/org/opendaylight/controller/sal/restconf/impl/BrokerFacade.java

   1 /**
   2  * Copyright (c) 2014 Cisco 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 package org.opendaylight.controller.sal.restconf.impl;
   9
  10 import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION;
  11 import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.OPERATIONAL;
  12 import com.google.common.base.Optional;
  13 import com.google.common.base.Preconditions;
  14 import com.google.common.util.concurrent.CheckedFuture;
  15 import com.google.common.util.concurrent.ListenableFuture;
  16 import java.util.ArrayList;
  17 import java.util.Iterator;
  18 import java.util.List;
  19 import java.util.concurrent.ExecutionException;
  20 import javax.ws.rs.core.Response.Status;
  21 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
  22 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  23 import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException;
  24 import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
  25 import org.opendaylight.controller.md.sal.dom.api.DOMDataChangeListener;
  26 import org.opendaylight.controller.md.sal.dom.api.DOMDataReadTransaction;
  27 import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction;
  28 import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction;
  29 import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint;
  30 import org.opendaylight.controller.md.sal.dom.api.DOMRpcException;
  31 import org.opendaylight.controller.md.sal.dom.api.DOMRpcResult;
  32 import org.opendaylight.controller.md.sal.dom.api.DOMRpcService;
  33 import org.opendaylight.controller.sal.core.api.Broker.ConsumerSession;
  34 import org.opendaylight.controller.sal.restconf.impl.RestconfError.ErrorTag;
  35 import org.opendaylight.controller.sal.restconf.impl.RestconfError.ErrorType;
  36 import org.opendaylight.controller.sal.streams.listeners.ListenerAdapter;
  37 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  38 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
  39 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier.PathArgument;
  40 import org.opendaylight.yangtools.yang.data.api.schema.MapEntryNode;
  41 import org.opendaylight.yangtools.yang.data.api.schema.MapNode;
  42 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
  43 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
  44 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  45 import org.opendaylight.yangtools.yang.model.api.SchemaPath;
  46 import org.slf4j.Logger;
  47 import org.slf4j.LoggerFactory;
  48
  49 public class BrokerFacade {
  50     private final static Logger LOG = LoggerFactory.getLogger(BrokerFacade.class);
  51
  52     private final static BrokerFacade INSTANCE = new BrokerFacade();
  53     private volatile DOMRpcService rpcService;
  54     private volatile ConsumerSession context;
  55     private DOMDataBroker domDataBroker;
  56
  57     private BrokerFacade() {
  58     }
  59
  60     public void setRpcService(final DOMRpcService router) {
  61         rpcService = router;
  62     }
  63
  64     public void setContext(final ConsumerSession context) {
  65         this.context = context;
  66     }
  67
  68     public static BrokerFacade getInstance() {
  69         return BrokerFacade.INSTANCE;
  70     }
  71
  72     private void checkPreconditions() {
  73         if (context == null || domDataBroker == null) {
  74             throw new RestconfDocumentedException(Status.SERVICE_UNAVAILABLE);
  75         }
  76     }
  77
  78     // READ configuration
  79     public NormalizedNode<?, ?> readConfigurationData(final YangInstanceIdentifier path) {
  80         checkPreconditions();
  81         return readDataViaTransaction(domDataBroker.newReadOnlyTransaction(), CONFIGURATION, path);
  82     }
  83
  84     public NormalizedNode<?, ?> readConfigurationData(final DOMMountPoint mountPoint, final YangInstanceIdentifier path) {
  85         final Optional<DOMDataBroker> domDataBrokerService = mountPoint.getService(DOMDataBroker.class);
  86         if (domDataBrokerService.isPresent()) {
  87             return readDataViaTransaction(domDataBrokerService.get().newReadOnlyTransaction(), CONFIGURATION, path);
  88         }
  89         final String errMsg = "DOM data broker service isn't available for mount point " + path;
  90         LOG.warn(errMsg);
  91         throw new RestconfDocumentedException(errMsg);
  92     }
  93
  94     // READ operational
  95     public NormalizedNode<?, ?> readOperationalData(final YangInstanceIdentifier path) {
  96         checkPreconditions();
  97         return readDataViaTransaction(domDataBroker.newReadOnlyTransaction(), OPERATIONAL, path);
  98     }
  99
 100     public NormalizedNode<?, ?> readOperationalData(final DOMMountPoint mountPoint, final YangInstanceIdentifier path) {
 101         final Optional<DOMDataBroker> domDataBrokerService = mountPoint.getService(DOMDataBroker.class);
 102         if (domDataBrokerService.isPresent()) {
 103             return readDataViaTransaction(domDataBrokerService.get().newReadOnlyTransaction(), OPERATIONAL, path);
 104         }
 105         final String errMsg = "DOM data broker service isn't available for mount point " + path;
 106         LOG.warn(errMsg);
 107         throw new RestconfDocumentedException(errMsg);
 108     }
 109
 110     // PUT configuration
 111     public CheckedFuture<Void, TransactionCommitFailedException> commitConfigurationDataPut(
 112             final SchemaContext globalSchema, final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload) {
 113         checkPreconditions();
 114         return putDataViaTransaction(domDataBroker.newReadWriteTransaction(), CONFIGURATION, path, payload, globalSchema);
 115     }
 116
 117     public CheckedFuture<Void, TransactionCommitFailedException> commitConfigurationDataPut(
 118             final DOMMountPoint mountPoint, final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload) {
 119         final Optional<DOMDataBroker> domDataBrokerService = mountPoint.getService(DOMDataBroker.class);
 120         if (domDataBrokerService.isPresent()) {
 121             return putDataViaTransaction(domDataBrokerService.get().newReadWriteTransaction(), CONFIGURATION, path,
 122                     payload, mountPoint.getSchemaContext());
 123         }
 124         final String errMsg = "DOM data broker service isn't available for mount point " + path;
 125         LOG.warn(errMsg);
 126         throw new RestconfDocumentedException(errMsg);
 127     }
 128
 129     // POST configuration
 130     public CheckedFuture<Void, TransactionCommitFailedException> commitConfigurationDataPost(
 131             final SchemaContext globalSchema, final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload) {
 132         checkPreconditions();
 133         return postDataViaTransaction(domDataBroker.newReadWriteTransaction(), CONFIGURATION, path, payload, globalSchema);
 134     }
 135
 136     public CheckedFuture<Void, TransactionCommitFailedException> commitConfigurationDataPost(
 137             final DOMMountPoint mountPoint, final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload) {
 138         final Optional<DOMDataBroker> domDataBrokerService = mountPoint.getService(DOMDataBroker.class);
 139         if (domDataBrokerService.isPresent()) {
 140             return postDataViaTransaction(domDataBrokerService.get().newReadWriteTransaction(), CONFIGURATION, path,
 141                     payload, mountPoint.getSchemaContext());
 142         }
 143         final String errMsg = "DOM data broker service isn't available for mount point " + path;
 144         LOG.warn(errMsg);
 145         throw new RestconfDocumentedException(errMsg);
 146     }
 147
 148     // DELETE configuration
 149     public CheckedFuture<Void, TransactionCommitFailedException> commitConfigurationDataDelete(
 150             final YangInstanceIdentifier path) {
 151         checkPreconditions();
 152         return deleteDataViaTransaction(domDataBroker.newWriteOnlyTransaction(), CONFIGURATION, path);
 153     }
 154
 155     public CheckedFuture<Void, TransactionCommitFailedException> commitConfigurationDataDelete(
 156             final DOMMountPoint mountPoint, final YangInstanceIdentifier path) {
 157         final Optional<DOMDataBroker> domDataBrokerService = mountPoint.getService(DOMDataBroker.class);
 158         if (domDataBrokerService.isPresent()) {
 159             return deleteDataViaTransaction(domDataBrokerService.get().newWriteOnlyTransaction(), CONFIGURATION, path);
 160         }
 161         final String errMsg = "DOM data broker service isn't available for mount point " + path;
 162         LOG.warn(errMsg);
 163         throw new RestconfDocumentedException(errMsg);
 164     }
 165
 166     // RPC
 167     public CheckedFuture<DOMRpcResult, DOMRpcException> invokeRpc(final SchemaPath type, final NormalizedNode<?, ?> input) {
 168         checkPreconditions();
 169         if (rpcService == null) {
 170             throw new RestconfDocumentedException(Status.SERVICE_UNAVAILABLE);
 171         }
 172         return rpcService.invokeRpc(type, input);
 173     }
 174
 175     public void registerToListenDataChanges(final LogicalDatastoreType datastore, final DataChangeScope scope,
 176             final ListenerAdapter listener) {
 177         checkPreconditions();
 178
 179         if (listener.isListening()) {
 180             return;
 181         }
 182
 183         final YangInstanceIdentifier path = listener.getPath();
 184         final ListenerRegistration<DOMDataChangeListener> registration = domDataBroker.registerDataChangeListener(
 185                 datastore, path, listener, scope);
 186
 187         listener.setRegistration(registration);
 188     }
 189
 190     private NormalizedNode<?, ?> readDataViaTransaction(final DOMDataReadTransaction transaction,
 191             final LogicalDatastoreType datastore, final YangInstanceIdentifier path) {
 192         LOG.trace("Read " + datastore.name() + " via Restconf: {}", path);
 193         final ListenableFuture<Optional<NormalizedNode<?, ?>>> listenableFuture = transaction.read(datastore, path);
 194         if (listenableFuture != null) {
 195             Optional<NormalizedNode<?, ?>> optional;
 196             try {
 197                 LOG.debug("Reading result data from transaction.");
 198                 optional = listenableFuture.get();
 199             } catch (InterruptedException | ExecutionException e) {
 200                 LOG.warn("Exception by reading " + datastore.name() + " via Restconf: {}", path, e);
 201                 throw new RestconfDocumentedException("Problem to get data from transaction.", e.getCause());
 202
 203             }
 204             if (optional != null) {
 205                 if (optional.isPresent()) {
 206                     return optional.get();
 207                 }
 208             }
 209         }
 210         return null;
 211     }
 212
 213     private CheckedFuture<Void, TransactionCommitFailedException> postDataViaTransaction(
 214             final DOMDataReadWriteTransaction rWTransaction, final LogicalDatastoreType datastore,
 215             final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload, final SchemaContext schemaContext) {
 216         // FIXME: This is doing correct post for container and list children
 217         //        not sure if this will work for choice case
 218         if(payload instanceof MapNode) {
 219             final NormalizedNode<?, ?> emptySubtree = ImmutableNodes.fromInstanceId(schemaContext, path);
 220             rWTransaction.merge(datastore, YangInstanceIdentifier.create(emptySubtree.getIdentifier()), emptySubtree);
 221             ensureParentsByMerge(datastore, path, rWTransaction, schemaContext);
 222             for(final MapEntryNode child : ((MapNode) payload).getValue()) {
 223                 final YangInstanceIdentifier childPath = path.node(child.getIdentifier());
 224                 checkItemDoesNotExists(rWTransaction, datastore, childPath);
 225                 rWTransaction.put(datastore, childPath, child);
 226             }
 227         } else {
 228             checkItemDoesNotExists(rWTransaction,datastore, path);
 229             ensureParentsByMerge(datastore, path, rWTransaction, schemaContext);
 230             rWTransaction.put(datastore, path, payload);
 231         }
 232         return rWTransaction.submit();
 233     }
 234
 235     private void checkItemDoesNotExists(final DOMDataReadWriteTransaction rWTransaction,final LogicalDatastoreType store, final YangInstanceIdentifier path) {
 236         final ListenableFuture<Boolean> futureDatastoreData = rWTransaction.exists(store, path);
 237         try {
 238             if (futureDatastoreData.get()) {
 239                 final String errMsg = "Post Configuration via Restconf was not executed because data already exists";
 240                 LOG.trace(errMsg + ":{}", path);
 241                 rWTransaction.cancel();
 242                 throw new RestconfDocumentedException("Data already exists for path: " + path, ErrorType.PROTOCOL,
 243                         ErrorTag.DATA_EXISTS);
 244             }
 245         } catch (InterruptedException | ExecutionException e) {
 246             LOG.warn("It wasn't possible to get data loaded from datastore at path " + path, e);
 247         }
 248
 249     }
 250
 251     private CheckedFuture<Void, TransactionCommitFailedException> putDataViaTransaction(
 252             final DOMDataReadWriteTransaction writeTransaction, final LogicalDatastoreType datastore,
 253             final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload, final SchemaContext schemaContext) {
 254         LOG.trace("Put " + datastore.name() + " via Restconf: {}", path);
 255         ensureParentsByMerge(datastore, path, writeTransaction, schemaContext);
 256         writeTransaction.put(datastore, path, payload);
 257         return writeTransaction.submit();
 258     }
 259
 260     private CheckedFuture<Void, TransactionCommitFailedException> deleteDataViaTransaction(
 261             final DOMDataWriteTransaction writeTransaction, final LogicalDatastoreType datastore,
 262             final YangInstanceIdentifier path) {
 263         LOG.trace("Delete " + datastore.name() + " via Restconf: {}", path);
 264         writeTransaction.delete(datastore, path);
 265         return writeTransaction.submit();
 266     }
 267
 268     public void setDomDataBroker(final DOMDataBroker domDataBroker) {
 269         this.domDataBroker = domDataBroker;
 270     }
 271
 272     private void ensureParentsByMerge(final LogicalDatastoreType store,
 273                                       final YangInstanceIdentifier normalizedPath, final DOMDataReadWriteTransaction rwTx, final SchemaContext schemaContext) {
 274         final List<PathArgument> normalizedPathWithoutChildArgs = new ArrayList<>();
 275         YangInstanceIdentifier rootNormalizedPath = null;
 276
 277         final Iterator<PathArgument> it = normalizedPath.getPathArguments().iterator();
 278
 279         while(it.hasNext()) {
 280             final PathArgument pathArgument = it.next();
 281             if(rootNormalizedPath == null) {
 282                 rootNormalizedPath = YangInstanceIdentifier.create(pathArgument);
 283             }
 284
 285             // Skip last element, its not a parent
 286             if(it.hasNext()) {
 287                 normalizedPathWithoutChildArgs.add(pathArgument);
 288             }
 289         }
 290
 291         // No parent structure involved, no need to ensure parents
 292         if(normalizedPathWithoutChildArgs.isEmpty()) {
 293             return;
 294         }
 295
 296         Preconditions.checkArgument(rootNormalizedPath != null, "Empty path received");
 297
 298         final NormalizedNode<?, ?> parentStructure =
 299                 ImmutableNodes.fromInstanceId(schemaContext, YangInstanceIdentifier.create(normalizedPathWithoutChildArgs));
 300         rwTx.merge(store, rootNormalizedPath, parentStructure);
 301     }
 302 }