X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-rest-connector%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fsal%2Frestconf%2Fimpl%2FBrokerFacade.java;h=be24fd26dd416f7d69838121cb7bf4f7ae2fdb0e;hb=25eb29c9dc9c6eb9604251f8973ba2f78948e7a8;hp=3d047dd07f53e47a4000a5de137fcc52e3affa75;hpb=81aa5072801e6453306e296b91dba3dbeeaf046d;p=controller.git diff --git a/opendaylight/md-sal/sal-rest-connector/src/main/java/org/opendaylight/controller/sal/restconf/impl/BrokerFacade.java b/opendaylight/md-sal/sal-rest-connector/src/main/java/org/opendaylight/controller/sal/restconf/impl/BrokerFacade.java index 3d047dd07f..be24fd26dd 100644 --- a/opendaylight/md-sal/sal-rest-connector/src/main/java/org/opendaylight/controller/sal/restconf/impl/BrokerFacade.java +++ b/opendaylight/md-sal/sal-rest-connector/src/main/java/org/opendaylight/controller/sal/restconf/impl/BrokerFacade.java @@ -7,193 +7,220 @@ */ package org.opendaylight.controller.sal.restconf.impl; -import com.google.common.util.concurrent.Futures; -import java.util.Collections; +import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.CONFIGURATION; +import static org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType.OPERATIONAL; + +import com.google.common.base.Optional; +import com.google.common.util.concurrent.CheckedFuture; +import com.google.common.util.concurrent.ListenableFuture; +import java.util.concurrent.ExecutionException; import java.util.concurrent.Future; import javax.ws.rs.core.Response.Status; -import org.opendaylight.controller.md.sal.common.api.TransactionStatus; -import org.opendaylight.controller.md.sal.common.api.data.DataReader; -import org.opendaylight.controller.sal.common.util.Rpcs; +import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope; +import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; +import org.opendaylight.controller.md.sal.common.api.data.TransactionCommitFailedException; +import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker; +import org.opendaylight.controller.md.sal.dom.api.DOMDataChangeListener; +import org.opendaylight.controller.md.sal.dom.api.DOMDataReadTransaction; +import org.opendaylight.controller.md.sal.dom.api.DOMDataReadWriteTransaction; +import org.opendaylight.controller.md.sal.dom.api.DOMDataWriteTransaction; +import org.opendaylight.controller.md.sal.dom.api.DOMMountPoint; import org.opendaylight.controller.sal.core.api.Broker.ConsumerSession; -import org.opendaylight.controller.sal.core.api.data.DataBrokerService; -import org.opendaylight.controller.sal.core.api.data.DataChangeListener; -import org.opendaylight.controller.sal.core.api.data.DataModificationTransaction; -import org.opendaylight.controller.sal.core.api.mount.MountInstance; import org.opendaylight.controller.sal.restconf.impl.RestconfError.ErrorTag; import org.opendaylight.controller.sal.restconf.impl.RestconfError.ErrorType; import org.opendaylight.controller.sal.streams.listeners.ListenerAdapter; import org.opendaylight.yangtools.concepts.ListenerRegistration; import org.opendaylight.yangtools.yang.common.QName; -import org.opendaylight.yangtools.yang.common.RpcError; import org.opendaylight.yangtools.yang.common.RpcResult; import org.opendaylight.yangtools.yang.data.api.CompositeNode; -import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; +import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -public class BrokerFacade implements DataReader { - private final static Logger LOG = LoggerFactory.getLogger( BrokerFacade.class ); +public class BrokerFacade { + private final static Logger LOG = LoggerFactory.getLogger(BrokerFacade.class); private final static BrokerFacade INSTANCE = new BrokerFacade(); - - private volatile DataBrokerService dataService; private volatile ConsumerSession context; + private DOMDataBroker domDataBroker; private BrokerFacade() { } - public void setContext( final ConsumerSession context ) { + public void setContext(final ConsumerSession context) { this.context = context; } - public void setDataService( final DataBrokerService dataService ) { - this.dataService = dataService; - } - public static BrokerFacade getInstance() { return BrokerFacade.INSTANCE; } private void checkPreconditions() { - if( context == null || dataService == null ) { - throw new RestconfDocumentedException( Status.SERVICE_UNAVAILABLE ); + if (context == null || domDataBroker == null) { + throw new RestconfDocumentedException(Status.SERVICE_UNAVAILABLE); } } - @Override - public CompositeNode readConfigurationData( final InstanceIdentifier path ) { - this.checkPreconditions(); - - LOG.trace( "Read Configuration via Restconf: {}", path ); - - return dataService.readConfigurationData( path ); + // READ configuration + public NormalizedNode readConfigurationData(final YangInstanceIdentifier path) { + checkPreconditions(); + return readDataViaTransaction(domDataBroker.newReadOnlyTransaction(), CONFIGURATION, path); } - public CompositeNode readConfigurationDataBehindMountPoint( final MountInstance mountPoint, - final InstanceIdentifier path ) { - this.checkPreconditions(); - - LOG.trace( "Read Configuration via Restconf: {}", path ); - - return mountPoint.readConfigurationData( path ); + public NormalizedNode readConfigurationData(final DOMMountPoint mountPoint, final YangInstanceIdentifier path) { + final Optional domDataBrokerService = mountPoint.getService(DOMDataBroker.class); + if (domDataBrokerService.isPresent()) { + return readDataViaTransaction(domDataBrokerService.get().newReadOnlyTransaction(), CONFIGURATION, path); + } + throw new RestconfDocumentedException("DOM data broker service isn't available for mount point."); } - @Override - public CompositeNode readOperationalData( final InstanceIdentifier path ) { - this.checkPreconditions(); - - BrokerFacade.LOG.trace( "Read Operational via Restconf: {}", path ); - - return dataService.readOperationalData( path ); + // READ operational + public NormalizedNode readOperationalData(final YangInstanceIdentifier path) { + checkPreconditions(); + return readDataViaTransaction(domDataBroker.newReadOnlyTransaction(), OPERATIONAL, path); } - public CompositeNode readOperationalDataBehindMountPoint( final MountInstance mountPoint, - final InstanceIdentifier path ) { - this.checkPreconditions(); - - BrokerFacade.LOG.trace( "Read Operational via Restconf: {}", path ); - - return mountPoint.readOperationalData( path ); + public NormalizedNode readOperationalData(final DOMMountPoint mountPoint, final YangInstanceIdentifier path) { + final Optional domDataBrokerService = mountPoint.getService(DOMDataBroker.class); + if (domDataBrokerService.isPresent()) { + return readDataViaTransaction(domDataBrokerService.get().newReadOnlyTransaction(), OPERATIONAL, path); + } + throw new RestconfDocumentedException("DOM data broker service isn't available for mount point."); } - public Future> invokeRpc( final QName type, final CompositeNode payload ) { - this.checkPreconditions(); - - return context.rpc( type, payload ); + // PUT configuration + public CheckedFuture commitConfigurationDataPut( + final YangInstanceIdentifier path, final NormalizedNode payload) { + checkPreconditions(); + return putDataViaTransaction(domDataBroker.newWriteOnlyTransaction(), CONFIGURATION, path, payload); } - public Future> commitConfigurationDataPut( final InstanceIdentifier path, - final CompositeNode payload ) { - this.checkPreconditions(); - - final DataModificationTransaction transaction = dataService.beginTransaction(); - BrokerFacade.LOG.trace( "Put Configuration via Restconf: {}", path ); - transaction.putConfigurationData( path, payload ); - return transaction.commit(); + public CheckedFuture commitConfigurationDataPut( + final DOMMountPoint mountPoint, final YangInstanceIdentifier path, final NormalizedNode payload) { + final Optional domDataBrokerService = mountPoint.getService(DOMDataBroker.class); + if (domDataBrokerService.isPresent()) { + return putDataViaTransaction(domDataBrokerService.get().newWriteOnlyTransaction(), CONFIGURATION, path, + payload); + } + throw new RestconfDocumentedException("DOM data broker service isn't available for mount point."); } - public Future> commitConfigurationDataPutBehindMountPoint( - final MountInstance mountPoint, final InstanceIdentifier path, final CompositeNode payload ) { - this.checkPreconditions(); - - final DataModificationTransaction transaction = mountPoint.beginTransaction(); - BrokerFacade.LOG.trace( "Put Configuration via Restconf: {}", path ); - transaction.putConfigurationData( path, payload ); - return transaction.commit(); + // POST configuration + public CheckedFuture commitConfigurationDataPost( + final YangInstanceIdentifier path, final NormalizedNode payload) { + checkPreconditions(); + return postDataViaTransaction(domDataBroker.newReadWriteTransaction(), CONFIGURATION, path, payload); } - public Future> commitConfigurationDataPost( final InstanceIdentifier path, - final CompositeNode payload) { - this.checkPreconditions(); - - final DataModificationTransaction transaction = dataService.beginTransaction(); - /* check for available Node in Configuration DataStore by path */ - CompositeNode availableNode = transaction.readConfigurationData( path ); - if (availableNode != null) { - String errMsg = "Post Configuration via Restconf was not executed because data already exists"; - BrokerFacade.LOG.warn((new StringBuilder(errMsg)).append(" : ").append(path).toString()); - - throw new RestconfDocumentedException( - "Data already exists for path: " + path, ErrorType.PROTOCOL, ErrorTag.DATA_EXISTS ); + public CheckedFuture commitConfigurationDataPost( + final DOMMountPoint mountPoint, final YangInstanceIdentifier path, final NormalizedNode payload) { + final Optional domDataBrokerService = mountPoint.getService(DOMDataBroker.class); + if (domDataBrokerService.isPresent()) { + return postDataViaTransaction(domDataBrokerService.get().newReadWriteTransaction(), CONFIGURATION, path, + payload); } - BrokerFacade.LOG.trace( "Post Configuration via Restconf: {}", path ); - transaction.putConfigurationData( path, payload ); - return transaction.commit(); + throw new RestconfDocumentedException("DOM data broker service isn't available for mount point."); } - public Future> commitConfigurationDataPostBehindMountPoint( - final MountInstance mountPoint, final InstanceIdentifier path, final CompositeNode payload ) { - this.checkPreconditions(); - - final DataModificationTransaction transaction = mountPoint.beginTransaction(); - /* check for available Node in Configuration DataStore by path */ - CompositeNode availableNode = transaction.readConfigurationData( path ); - if (availableNode != null) { - String errMsg = "Post Configuration via Restconf was not executed because data already exists"; - BrokerFacade.LOG.warn((new StringBuilder(errMsg)).append(" : ").append(path).toString()); - - throw new RestconfDocumentedException( - "Data already exists for path: " + path, ErrorType.PROTOCOL, ErrorTag.DATA_EXISTS ); - } - BrokerFacade.LOG.trace( "Post Configuration via Restconf: {}", path ); - transaction.putConfigurationData( path, payload ); - return transaction.commit(); + // DELETE configuration + public CheckedFuture commitConfigurationDataDelete( + final YangInstanceIdentifier path) { + checkPreconditions(); + return deleteDataViaTransaction(domDataBroker.newWriteOnlyTransaction(), CONFIGURATION, path); } - public Future> commitConfigurationDataDelete( final InstanceIdentifier path ) { - this.checkPreconditions(); - return deleteDataAtTarget(path,dataService.beginTransaction()); + public CheckedFuture commitConfigurationDataDelete( + final DOMMountPoint mountPoint, final YangInstanceIdentifier path) { + final Optional domDataBrokerService = mountPoint.getService(DOMDataBroker.class); + if (domDataBrokerService.isPresent()) { + return deleteDataViaTransaction(domDataBrokerService.get().newWriteOnlyTransaction(), CONFIGURATION, path); + } + throw new RestconfDocumentedException("DOM data broker service isn't available for mount point."); } - public Future> commitConfigurationDataDeleteBehindMountPoint( - final MountInstance mountPoint, final InstanceIdentifier path ) { + // RPC + public Future> invokeRpc(final QName type, final CompositeNode payload) { this.checkPreconditions(); - return deleteDataAtTarget(path,mountPoint.beginTransaction()); - } - private Future> deleteDataAtTarget(final InstanceIdentifier path, - final DataModificationTransaction transaction) { - LOG.info("Delete Configuration via Restconf: {}", path); - CompositeNode redDataAtPath = transaction.readConfigurationData(path); - if (redDataAtPath == null) { - return Futures.immediateFuture(Rpcs. getRpcResult(true, TransactionStatus.COMMITED, - Collections. emptyList())); - } - transaction.removeConfigurationData(path); - return transaction.commit(); + return context.rpc(type, payload); } - public void registerToListenDataChanges( final ListenerAdapter listener ) { + public void registerToListenDataChanges(final LogicalDatastoreType datastore, final DataChangeScope scope, + final ListenerAdapter listener) { this.checkPreconditions(); - if( listener.isListening() ) { + if (listener.isListening()) { return; } - InstanceIdentifier path = listener.getPath(); - final ListenerRegistration registration = - dataService.registerDataChangeListener( path, listener ); + YangInstanceIdentifier path = listener.getPath(); + final ListenerRegistration registration = domDataBroker.registerDataChangeListener( + datastore, path, listener, scope); + + listener.setRegistration(registration); + } + + private NormalizedNode readDataViaTransaction(final DOMDataReadTransaction transaction, + LogicalDatastoreType datastore, YangInstanceIdentifier path) { + LOG.trace("Read " + datastore.name() + " via Restconf: {}", path); + final ListenableFuture>> listenableFuture = transaction.read(datastore, path); + if (listenableFuture != null) { + Optional> optional; + try { + LOG.debug("Reading result data from transaction."); + optional = listenableFuture.get(); + } catch (InterruptedException | ExecutionException e) { + throw new RestconfDocumentedException("Problem to get data from transaction.", e.getCause()); + + } + if (optional != null) { + if (optional.isPresent()) { + return optional.get(); + } + } + } + return null; + } + + private CheckedFuture postDataViaTransaction( + final DOMDataReadWriteTransaction rWTransaction, final LogicalDatastoreType datastore, + final YangInstanceIdentifier path, final NormalizedNode payload) { + ListenableFuture>> futureDatastoreData = rWTransaction.read(datastore, path); + try { + final Optional> optionalDatastoreData = futureDatastoreData.get(); + if (optionalDatastoreData.isPresent() && payload.equals(optionalDatastoreData.get())) { + String errMsg = "Post Configuration via Restconf was not executed because data already exists"; + LOG.trace(errMsg + ":{}", path); + throw new RestconfDocumentedException("Data already exists for path: " + path, ErrorType.PROTOCOL, + ErrorTag.DATA_EXISTS); + } + } catch (InterruptedException | ExecutionException e) { + LOG.trace("It wasn't possible to get data loaded from datastore at path " + path); + } + rWTransaction.merge(datastore, path, payload); + LOG.trace("Post " + datastore.name() + " via Restconf: {}", path); + return rWTransaction.submit(); + } + + private CheckedFuture putDataViaTransaction( + final DOMDataWriteTransaction writeTransaction, final LogicalDatastoreType datastore, + final YangInstanceIdentifier path, final NormalizedNode payload) { + LOG.trace("Put " + datastore.name() + " via Restconf: {}", path); + writeTransaction.put(datastore, path, payload); + return writeTransaction.submit(); + } + + private CheckedFuture deleteDataViaTransaction( + final DOMDataWriteTransaction writeTransaction, final LogicalDatastoreType datastore, + YangInstanceIdentifier path) { + LOG.info("Delete " + datastore.name() + " via Restconf: {}", path); + writeTransaction.delete(datastore, path); + return writeTransaction.submit(); + } - listener.setRegistration( registration ); + public void setDomDataBroker(DOMDataBroker domDataBroker) { + this.domDataBroker = domDataBroker; } }