X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=opendaylight%2Fmd-sal%2Fsal-dom-broker%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Fcontroller%2Fmd%2Fsal%2Fdom%2Fbroker%2Fimpl%2Fcompat%2FBackwardsCompatibleDataBroker.java;h=2d715e348588f8479cf61a12ccbcfd81d5c19f53;hb=1e12c13aaec75493f70dd759208181f45c385102;hp=b2217a6f0a0ba70cb7947a0b825c8e77f7d65648;hpb=721b580748cb93b3dac952ff1f111d0ab0da0c79;p=controller.git diff --git a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/compat/BackwardsCompatibleDataBroker.java b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/compat/BackwardsCompatibleDataBroker.java index b2217a6f0a..2d715e3485 100644 --- a/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/compat/BackwardsCompatibleDataBroker.java +++ b/opendaylight/md-sal/sal-dom-broker/src/main/java/org/opendaylight/controller/md/sal/dom/broker/impl/compat/BackwardsCompatibleDataBroker.java @@ -1,49 +1,49 @@ +/* + * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 which accompanies this distribution, + * and is available at http://www.eclipse.org/legal/epl-v10.html. + */ package org.opendaylight.controller.md.sal.dom.broker.impl.compat; +import javax.annotation.concurrent.ThreadSafe; import org.opendaylight.controller.md.sal.common.api.RegistrationListener; -import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent; -import org.opendaylight.controller.md.sal.common.api.data.DataChangeEvent; import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler; import org.opendaylight.controller.md.sal.common.api.data.DataCommitHandlerRegistration; import org.opendaylight.controller.md.sal.common.api.data.DataReader; import org.opendaylight.controller.md.sal.common.impl.util.compat.DataNormalizer; import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker; -import org.opendaylight.controller.md.sal.dom.api.DOMDataChangeListener; import org.opendaylight.controller.sal.common.DataStoreIdentifier; 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.data.DataProviderService; import org.opendaylight.controller.sal.core.api.data.DataValidator; +import org.opendaylight.controller.sal.core.api.model.SchemaService; import org.opendaylight.yangtools.concepts.AbstractObjectRegistration; -import org.opendaylight.yangtools.concepts.Delegator; import org.opendaylight.yangtools.concepts.ListenerRegistration; import org.opendaylight.yangtools.concepts.Registration; -import org.opendaylight.yangtools.concepts.util.ListenerRegistry; import org.opendaylight.yangtools.yang.data.api.CompositeNode; -import org.opendaylight.yangtools.yang.data.api.InstanceIdentifier; -import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode; +import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier; import org.opendaylight.yangtools.yang.model.api.SchemaContext; import org.opendaylight.yangtools.yang.model.api.SchemaContextListener; -public class BackwardsCompatibleDataBroker implements DataProviderService, SchemaContextListener { +@Deprecated +@ThreadSafe +public class BackwardsCompatibleDataBroker implements DataProviderService { - DOMDataBroker backingBroker; - DataNormalizer normalizer; - private final ListenerRegistry fakeRegistry = ListenerRegistry.create(); + private final DOMDataBroker backingBroker; + private volatile DataNormalizer normalizer; + private final ListenerRegistration schemaReg; - - public BackwardsCompatibleDataBroker(final DOMDataBroker newBiDataImpl) { + public BackwardsCompatibleDataBroker(final DOMDataBroker newBiDataImpl, final SchemaService schemaService) { backingBroker = newBiDataImpl; + schemaReg = schemaService.registerSchemaContextListener(new SchemaListener()); } @Override - public void onGlobalContextUpdated(final SchemaContext ctx) { - normalizer = new DataNormalizer(ctx); - } - - @Override - public CompositeNode readConfigurationData(final InstanceIdentifier legacyPath) { - BackwardsCompatibleTransaction tx = BackwardsCompatibleTransaction.readOnlyTransaction(backingBroker.newReadOnlyTransaction(),normalizer); + public CompositeNode readConfigurationData(final YangInstanceIdentifier legacyPath) { + final BackwardsCompatibleTransaction tx = BackwardsCompatibleTransaction.readOnlyTransaction(backingBroker.newReadOnlyTransaction(),normalizer); try { return tx.readConfigurationData(legacyPath); } finally { @@ -52,8 +52,8 @@ public class BackwardsCompatibleDataBroker implements DataProviderService, Schem } @Override - public CompositeNode readOperationalData(final InstanceIdentifier legacyPath) { - BackwardsCompatibleTransaction tx = BackwardsCompatibleTransaction.readOnlyTransaction(backingBroker.newReadOnlyTransaction(),normalizer); + public CompositeNode readOperationalData(final YangInstanceIdentifier legacyPath) { + final BackwardsCompatibleTransaction tx = BackwardsCompatibleTransaction.readOnlyTransaction(backingBroker.newReadOnlyTransaction(),normalizer); try { return tx.readOperationalData(legacyPath); } finally { @@ -67,16 +67,26 @@ public class BackwardsCompatibleDataBroker implements DataProviderService, Schem } @Override - public ListenerRegistration registerDataChangeListener(final InstanceIdentifier path, + public ListenerRegistration registerDataChangeListener(final YangInstanceIdentifier legacyPath, final DataChangeListener listener) { - return fakeRegistry .register(listener); + final YangInstanceIdentifier normalizedPath = normalizer.toNormalized(legacyPath); + + final TranslatingListenerInvoker translatingCfgListener = + TranslatingListenerInvoker.createConfig(listener, normalizer); + translatingCfgListener.register(backingBroker, normalizedPath); + + final TranslatingListenerInvoker translatingOpListener = + TranslatingListenerInvoker.createOperational(listener, normalizer); + translatingOpListener.register(backingBroker, normalizedPath); + + return new DelegateListenerRegistration(translatingCfgListener, translatingOpListener, listener); } @Override - public Registration> registerCommitHandler( - final InstanceIdentifier path, final DataCommitHandler commitHandler) { + public Registration registerCommitHandler( + final YangInstanceIdentifier path, final DataCommitHandler commitHandler) { // FIXME Do real forwarding - return new AbstractObjectRegistration>(commitHandler) { + return new AbstractObjectRegistration>(commitHandler) { @Override protected void removeRegistration() { // NOOP @@ -85,12 +95,12 @@ public class BackwardsCompatibleDataBroker implements DataProviderService, Schem } @Override - public ListenerRegistration>> registerCommitHandlerListener( - final RegistrationListener> commitHandlerListener) { + public ListenerRegistration>> registerCommitHandlerListener( + final RegistrationListener> commitHandlerListener) { return null; } - // Obsolote functionality + // Obsolete functionality @Override public void addValidator(final DataStoreIdentifier store, final DataValidator validator) { @@ -113,36 +123,46 @@ public class BackwardsCompatibleDataBroker implements DataProviderService, Schem } @Override - public Registration> registerConfigurationReader( - final InstanceIdentifier path, final DataReader reader) { + public Registration registerConfigurationReader( + final YangInstanceIdentifier path, final DataReader reader) { throw new UnsupportedOperationException("Data Reader contract is not supported."); } @Override - public Registration> registerOperationalReader( - final InstanceIdentifier path, final DataReader reader) { + public Registration registerOperationalReader( + final YangInstanceIdentifier path, final DataReader reader) { throw new UnsupportedOperationException("Data Reader contract is not supported."); } - private final class TranslatingListenerInvoker implements DOMDataChangeListener, Delegator { - + private static class DelegateListenerRegistration implements ListenerRegistration { + private final TranslatingListenerInvoker translatingCfgListener; + private final TranslatingListenerInvoker translatingOpListener; + private final DataChangeListener listener; - private DataChangeListener delegate; + public DelegateListenerRegistration(final TranslatingListenerInvoker translatingCfgListener, final TranslatingListenerInvoker translatingOpListener, final DataChangeListener listener) { + this.translatingCfgListener = translatingCfgListener; + this.translatingOpListener = translatingOpListener; + this.listener = listener; + } @Override - public void onDataChanged(final AsyncDataChangeEvent> normalizedChange) { - - DataChangeEvent legacyChange = null; - delegate.onDataChanged(legacyChange); + public void close() { + translatingCfgListener.close(); + translatingOpListener.close(); } @Override - public DataChangeListener getDelegate() { - - return delegate; + public DataChangeListener getInstance() { + return listener; } + } + private class SchemaListener implements SchemaContextListener { - } + @Override + public void onGlobalContextUpdated(final SchemaContext ctx) { + normalizer = new DataNormalizer(ctx); + } + } }