opendaylight/restconf/sal-rest-connector/src/main/java/org/opendaylight/netconf/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.netconf.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.netconf.sal.restconf.impl.RestconfError.ErrorTag;
  35 import org.opendaylight.netconf.sal.restconf.impl.RestconfError.ErrorType;
  36 import org.opendaylight.netconf.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         LOG.trace("Invoke RPC {} with input: {}", type, input);
 173         return rpcService.invokeRpc(type, input);
 174     }
 175
 176     public void registerToListenDataChanges(final LogicalDatastoreType datastore, final DataChangeScope scope,
 177             final ListenerAdapter listener) {
 178         checkPreconditions();
 179
 180         if (listener.isListening()) {
 181             return;
 182         }
 183
 184         final YangInstanceIdentifier path = listener.getPath();
 185         final ListenerRegistration<DOMDataChangeListener> registration = domDataBroker.registerDataChangeListener(
 186                 datastore, path, listener, scope);
 187
 188         listener.setRegistration(registration);
 189     }
 190
 191     private NormalizedNode<?, ?> readDataViaTransaction(final DOMDataReadTransaction transaction,
 192             final LogicalDatastoreType datastore, final YangInstanceIdentifier path) {
 193         LOG.trace("Read " + datastore.name() + " via Restconf: {}", path);
 194         final ListenableFuture<Optional<NormalizedNode<?, ?>>> listenableFuture = transaction.read(datastore, path);
 195         if (listenableFuture != null) {
 196             Optional<NormalizedNode<?, ?>> optional;
 197             try {
 198                 LOG.debug("Reading result data from transaction.");
 199                 optional = listenableFuture.get();
 200             } catch (InterruptedException | ExecutionException e) {
 201                 LOG.warn("Exception by reading " + datastore.name() + " via Restconf: {}", path, e);
 202                 throw new RestconfDocumentedException("Problem to get data from transaction.", e.getCause());
 203
 204             }
 205             if (optional != null) {
 206                 if (optional.isPresent()) {
 207                     return optional.get();
 208                 }
 209             }
 210         }
 211         return null;
 212     }
 213
 214     private CheckedFuture<Void, TransactionCommitFailedException> postDataViaTransaction(
 215             final DOMDataReadWriteTransaction rWTransaction, final LogicalDatastoreType datastore,
 216             final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload, final SchemaContext schemaContext) {
 217         // FIXME: This is doing correct post for container and list children
 218         //        not sure if this will work for choice case
 219         if(payload instanceof MapNode) {
 220             LOG.trace("POST " + datastore.name() + " via Restconf: {} with payload {}", path, payload);
 221             final NormalizedNode<?, ?> emptySubtree = ImmutableNodes.fromInstanceId(schemaContext, path);
 222             rWTransaction.merge(datastore, YangInstanceIdentifier.create(emptySubtree.getIdentifier()), emptySubtree);
 223             ensureParentsByMerge(datastore, path, rWTransaction, schemaContext);
 224             for(final MapEntryNode child : ((MapNode) payload).getValue()) {
 225                 final YangInstanceIdentifier childPath = path.node(child.getIdentifier());
 226                 checkItemDoesNotExists(rWTransaction, datastore, childPath);
 227                 rWTransaction.put(datastore, childPath, child);
 228             }
 229         } else {
 230             checkItemDoesNotExists(rWTransaction,datastore, path);
 231             ensureParentsByMerge(datastore, path, rWTransaction, schemaContext);
 232             rWTransaction.put(datastore, path, payload);
 233         }
 234         return rWTransaction.submit();
 235     }
 236
 237     private void checkItemDoesNotExists(final DOMDataReadWriteTransaction rWTransaction,final LogicalDatastoreType store, final YangInstanceIdentifier path) {
 238         final ListenableFuture<Boolean> futureDatastoreData = rWTransaction.exists(store, path);
 239         try {
 240             if (futureDatastoreData.get()) {
 241                 final String errMsg = "Post Configuration via Restconf was not executed because data already exists";
 242                 LOG.trace(errMsg + ":{}", path);
 243                 rWTransaction.cancel();
 244                 throw new RestconfDocumentedException("Data already exists for path: " + path, ErrorType.PROTOCOL,
 245                         ErrorTag.DATA_EXISTS);
 246             }
 247         } catch (InterruptedException | ExecutionException e) {
 248             LOG.warn("It wasn't possible to get data loaded from datastore at path " + path, e);
 249         }
 250
 251     }
 252
 253     private CheckedFuture<Void, TransactionCommitFailedException> putDataViaTransaction(
 254             final DOMDataReadWriteTransaction writeTransaction, final LogicalDatastoreType datastore,
 255             final YangInstanceIdentifier path, final NormalizedNode<?, ?> payload, final SchemaContext schemaContext) {
 256         LOG.trace("Put " + datastore.name() + " via Restconf: {} with payload {}", path, payload);
 257         ensureParentsByMerge(datastore, path, writeTransaction, schemaContext);
 258         writeTransaction.put(datastore, path, payload);
 259         return writeTransaction.submit();
 260     }
 261
 262     private CheckedFuture<Void, TransactionCommitFailedException> deleteDataViaTransaction(
 263             final DOMDataWriteTransaction writeTransaction, final LogicalDatastoreType datastore,
 264             final YangInstanceIdentifier path) {
 265         LOG.trace("Delete " + datastore.name() + " via Restconf: {}", path);
 266         writeTransaction.delete(datastore, path);
 267         return writeTransaction.submit();
 268     }
 269
 270     public void setDomDataBroker(final DOMDataBroker domDataBroker) {
 271         this.domDataBroker = domDataBroker;
 272     }
 273
 274     private void ensureParentsByMerge(final LogicalDatastoreType store,
 275                                       final YangInstanceIdentifier normalizedPath, final DOMDataReadWriteTransaction rwTx, final SchemaContext schemaContext) {
 276         final List<PathArgument> normalizedPathWithoutChildArgs = new ArrayList<>();
 277         YangInstanceIdentifier rootNormalizedPath = null;
 278
 279         final Iterator<PathArgument> it = normalizedPath.getPathArguments().iterator();
 280
 281         while(it.hasNext()) {
 282             final PathArgument pathArgument = it.next();
 283             if(rootNormalizedPath == null) {
 284                 rootNormalizedPath = YangInstanceIdentifier.create(pathArgument);
 285             }
 286
 287             // Skip last element, its not a parent
 288             if(it.hasNext()) {
 289                 normalizedPathWithoutChildArgs.add(pathArgument);
 290             }
 291         }
 292
 293         // No parent structure involved, no need to ensure parents
 294         if(normalizedPathWithoutChildArgs.isEmpty()) {
 295             return;
 296         }
 297
 298         Preconditions.checkArgument(rootNormalizedPath != null, "Empty path received");
 299
 300         final NormalizedNode<?, ?> parentStructure =
 301                 ImmutableNodes.fromInstanceId(schemaContext, YangInstanceIdentifier.create(normalizedPathWithoutChildArgs));
 302         rwTx.merge(store, rootNormalizedPath, parentStructure);
 303     }
 304 }