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=68c9340bb1672551c1479a8a267474bd7302cfd3;hpb=bcd476464c8d4b01af8a617b866bbe62b0705d41;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 68c9340bb1..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,201 +7,220 @@ */ package org.opendaylight.controller.sal.restconf.impl; -import com.google.common.base.Objects; +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 java.util.Map; +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.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.rest.impl.RestconfProvider; -import org.opendaylight.controller.sal.restconf.impl.ResponseException; +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.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 ) { - ResponseException _responseException = new ResponseException( Status.SERVICE_UNAVAILABLE, - RestconfProvider.NOT_INITALIZED_MSG ); - throw _responseException; + 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 ); + 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."); + } - return mountPoint.readOperationalData( path ); + // PUT configuration + public CheckedFuture commitConfigurationDataPut( + final YangInstanceIdentifier path, final NormalizedNode payload) { + checkPreconditions(); + return putDataViaTransaction(domDataBroker.newWriteOnlyTransaction(), CONFIGURATION, path, payload); } - public RpcResult invokeRpc( final QName type, final CompositeNode payload ) { - this.checkPreconditions(); + 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."); + } - final Future> future = context.rpc( type, payload ); + // POST configuration + public CheckedFuture commitConfigurationDataPost( + final YangInstanceIdentifier path, final NormalizedNode payload) { + checkPreconditions(); + return postDataViaTransaction(domDataBroker.newReadWriteTransaction(), CONFIGURATION, path, payload); + } - try { - return future.get(); - } - catch( Exception e ) { - throw new ResponseException( e, "Error invoking RPC " + type ); + 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); } + throw new RestconfDocumentedException("DOM data broker service isn't available for mount point."); } - public Future> commitConfigurationDataPut( final InstanceIdentifier path, - final CompositeNode payload ) { - this.checkPreconditions(); + // DELETE configuration + public CheckedFuture commitConfigurationDataDelete( + final YangInstanceIdentifier path) { + checkPreconditions(); + return deleteDataViaTransaction(domDataBroker.newWriteOnlyTransaction(), CONFIGURATION, path); + } - final DataModificationTransaction transaction = dataService.beginTransaction(); - BrokerFacade.LOG.trace( "Put Configuration via Restconf: {}", path ); - transaction.putConfigurationData( path, payload ); - return transaction.commit(); + 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> commitConfigurationDataPutBehindMountPoint( - final MountInstance mountPoint, final InstanceIdentifier path, final CompositeNode payload ) { + // RPC + public Future> invokeRpc(final QName type, 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(); + return context.rpc(type, payload); } - public Future> commitConfigurationDataPost( final InstanceIdentifier path, - final CompositeNode payload ) { + public void registerToListenDataChanges(final LogicalDatastoreType datastore, final DataChangeScope scope, + final ListenerAdapter listener) { this.checkPreconditions(); - final DataModificationTransaction transaction = dataService.beginTransaction(); - transaction.putConfigurationData( path, payload ); - Map createdConfigurationData = - transaction.getCreatedConfigurationData(); - CompositeNode createdNode = createdConfigurationData.get( path ); - - if( Objects.equal( payload, createdNode ) ) { - LOG.trace( "Post Configuration via Restconf: {}", path ); - return transaction.commit(); + if (listener.isListening()) { + return; } - LOG.trace( "Post Configuration via Restconf was not executed because data already exists: {}", - path ); + 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; } - public Future> commitConfigurationDataPostBehindMountPoint( - final MountInstance mountPoint, final InstanceIdentifier path, final CompositeNode payload ) { - this.checkPreconditions(); - - final DataModificationTransaction transaction = mountPoint.beginTransaction(); - transaction.putConfigurationData( path, payload ); - Map createdConfigurationData = - transaction.getCreatedConfigurationData(); - CompositeNode createdNode = createdConfigurationData.get( path ); - - if( Objects.equal( payload, createdNode ) ) { - LOG.trace( "Post Configuration via Restconf: {}", path ); - return transaction.commit(); + 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); } - - LOG.trace( "Post Configuration via Restconf was not executed because data already exists: {}", - path ); - return null; + rWTransaction.merge(datastore, path, payload); + LOG.trace("Post " + datastore.name() + " via Restconf: {}", path); + return rWTransaction.submit(); } - public Future> commitConfigurationDataDelete( final InstanceIdentifier path ) { - this.checkPreconditions(); - - final DataModificationTransaction transaction = dataService.beginTransaction(); - LOG.info( "Delete Configuration via Restconf: {}", path ); - transaction.removeConfigurationData( path ); - return transaction.commit(); + 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(); } - public Future> commitConfigurationDataDeleteBehindMountPoint( - final MountInstance mountPoint, final InstanceIdentifier path ) { - this.checkPreconditions(); - - final DataModificationTransaction transaction = mountPoint.beginTransaction(); - LOG.info( "Delete Configuration via Restconf: {}", path ); - transaction.removeConfigurationData( path ); - return transaction.commit(); + 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(); } - public void registerToListenDataChanges( final ListenerAdapter listener ) { - this.checkPreconditions(); - - if( listener.isListening() ) { - return; - } - - InstanceIdentifier path = listener.getPath(); - final ListenerRegistration registration = - dataService.registerDataChangeListener( path, listener ); - - listener.setRegistration( registration ); + public void setDomDataBroker(DOMDataBroker domDataBroker) { + this.domDataBroker = domDataBroker; } }