Bug 629: Make BindingDataBroker to be visible.
[controller.git] / opendaylight / md-sal / sal-binding-broker / src / test / java / org / opendaylight / controller / sal / binding / test / util / BindingTestContext.java
index ef3e9483315d93fe0237b32652e49f49c84532ab..623b2fdd6365c5f14d3948d2b567ab65c81435cd 100644 (file)
@@ -7,6 +7,8 @@
  */
 package org.opendaylight.controller.sal.binding.test.util;
 
+import static com.google.common.base.Preconditions.checkState;
+
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.List;
@@ -15,6 +17,12 @@ import java.util.concurrent.Future;
 
 import javassist.ClassPool;
 
+import org.opendaylight.controller.md.sal.binding.impl.ForwardedBackwardsCompatibleDataBroker;
+import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.controller.md.sal.dom.api.DOMDataBroker;
+import org.opendaylight.controller.md.sal.dom.broker.impl.DOMDataBrokerImpl;
+import org.opendaylight.controller.md.sal.dom.broker.impl.compat.BackwardsCompatibleDataBroker;
+import org.opendaylight.controller.md.sal.dom.store.impl.InMemoryDOMDataStore;
 import org.opendaylight.controller.sal.binding.api.RpcProviderRegistry;
 import org.opendaylight.controller.sal.binding.api.data.DataProviderService;
 import org.opendaylight.controller.sal.binding.api.mount.MountProviderService;
@@ -33,13 +41,13 @@ import org.opendaylight.controller.sal.core.api.RpcProvisionRegistry;
 import org.opendaylight.controller.sal.core.api.RpcRegistrationListener;
 import org.opendaylight.controller.sal.core.api.data.DataStore;
 import org.opendaylight.controller.sal.core.api.mount.MountProvisionService;
+import org.opendaylight.controller.sal.core.spi.data.DOMStore;
 import org.opendaylight.controller.sal.dom.broker.BrokerImpl;
 import org.opendaylight.controller.sal.dom.broker.MountPointManagerImpl;
 import org.opendaylight.controller.sal.dom.broker.impl.DataStoreStatsWrapper;
 import org.opendaylight.controller.sal.dom.broker.impl.HashMapDataStore;
 import org.opendaylight.controller.sal.dom.broker.impl.SchemaAwareDataStoreAdapter;
 import org.opendaylight.controller.sal.dom.broker.impl.SchemaAwareRpcBroker;
-import org.opendaylight.controller.sal.dom.broker.impl.SchemaContextProvider;
 import org.opendaylight.yangtools.concepts.ListenerRegistration;
 import org.opendaylight.yangtools.sal.binding.generator.impl.RuntimeGeneratedMappingServiceImpl;
 import org.opendaylight.yangtools.yang.common.QName;
@@ -57,11 +65,10 @@ import org.slf4j.LoggerFactory;
 import com.google.common.base.Predicate;
 import com.google.common.collect.ClassToInstanceMap;
 import com.google.common.collect.ImmutableClassToInstanceMap;
+import com.google.common.collect.ImmutableMap;
 import com.google.common.util.concurrent.ListeningExecutorService;
 
-import static com.google.common.base.Preconditions.*;
-
-public class BindingTestContext implements AutoCloseable, SchemaContextProvider {
+public class BindingTestContext implements AutoCloseable {
 
     public static final org.opendaylight.yangtools.yang.data.api.InstanceIdentifier TREE_ROOT = org.opendaylight.yangtools.yang.data.api.InstanceIdentifier
             .builder().toInstance();
@@ -76,13 +83,14 @@ public class BindingTestContext implements AutoCloseable, SchemaContextProvider
     private BindingIndependentConnector baConnectImpl;
 
     private org.opendaylight.controller.sal.dom.broker.DataBrokerImpl biDataImpl;
+    private org.opendaylight.controller.sal.core.api.data.DataProviderService biDataLegacyBroker;
     private BrokerImpl biBrokerImpl;
     private HashMapDataStore rawDataStore;
     private SchemaAwareDataStoreAdapter schemaAwareDataStore;
     private DataStoreStatsWrapper dataStoreStats;
     private DataStore dataStore;
 
-    private boolean dataStoreStatisticsEnabled = false;
+    private final boolean dataStoreStatisticsEnabled = false;
 
     private final ListeningExecutorService executor;
     private final ClassPool classPool;
@@ -91,18 +99,31 @@ public class BindingTestContext implements AutoCloseable, SchemaContextProvider
 
     private MountPointManagerImpl biMountImpl;
 
-    private SchemaContext schemaContext;
 
-    public SchemaContext getSchemaContext() {
-        return schemaContext;
+
+    private ImmutableMap<LogicalDatastoreType, DOMStore> newDatastores;
+
+    private BackwardsCompatibleDataBroker biCompatibleBroker;
+
+    private DataProviderService baData;
+
+    private DOMDataBroker newDOMDataBroker;
+
+    private final MockSchemaService mockSchemaService = new MockSchemaService();
+
+
+
+    public DOMDataBroker getDomAsyncDataBroker() {
+        return newDOMDataBroker;
     }
 
-    protected BindingTestContext(ListeningExecutorService executor, ClassPool classPool, boolean startWithSchema) {
+    protected BindingTestContext(final ListeningExecutorService executor, final ClassPool classPool, final boolean startWithSchema) {
         this.executor = executor;
         this.classPool = classPool;
         this.startWithSchema = startWithSchema;
     }
 
+    @Deprecated
     public void startDomDataStore() {
         checkState(dataStore == null, "DataStore already started.");
         checkState(biDataImpl != null, "Dom Data Broker not present");
@@ -115,7 +136,7 @@ public class BindingTestContext implements AutoCloseable, SchemaContextProvider
         } else {
             dataStore = schemaAwareDataStore;
         }
-
+        mockSchemaService.registerSchemaServiceListener(schemaAwareDataStore);
         biDataImpl.registerConfigurationReader(TREE_ROOT, dataStore);
         biDataImpl.registerOperationalReader(TREE_ROOT, dataStore);
         biDataImpl.registerCommitHandler(TREE_ROOT, dataStore);
@@ -125,31 +146,52 @@ public class BindingTestContext implements AutoCloseable, SchemaContextProvider
         checkState(executor != null, "Executor needs to be set");
         biDataImpl = new org.opendaylight.controller.sal.dom.broker.DataBrokerImpl();
         biDataImpl.setExecutor(executor);
+        biDataLegacyBroker = biDataImpl;
+    }
+
+    public void startNewDomDataBroker() {
+        checkState(executor != null, "Executor needs to be set");
+        InMemoryDOMDataStore operStore = new InMemoryDOMDataStore("OPER", executor);
+        InMemoryDOMDataStore configStore = new InMemoryDOMDataStore("CFG", executor);
+        newDatastores = ImmutableMap.<LogicalDatastoreType, DOMStore>builder()
+                .put(LogicalDatastoreType.OPERATIONAL, operStore)
+                .put(LogicalDatastoreType.CONFIGURATION, configStore)
+                .build();
+
+        newDOMDataBroker = new DOMDataBrokerImpl(newDatastores, executor);
+
+        biCompatibleBroker = new BackwardsCompatibleDataBroker(newDOMDataBroker);
+
+        mockSchemaService.registerSchemaServiceListener(configStore);
+        mockSchemaService.registerSchemaServiceListener(operStore);
+        mockSchemaService.registerSchemaServiceListener(biCompatibleBroker);
+        biDataLegacyBroker = biCompatibleBroker;
     }
 
     public void startBindingDataBroker() {
         checkState(executor != null, "Executor needs to be set");
         baDataImpl = new DataBrokerImpl();
         baDataImpl.setExecutor(executor);
+        baData = baDataImpl;
     }
 
     public void startBindingBroker() {
         checkState(executor != null, "Executor needs to be set");
-        checkState(baDataImpl != null, "Binding Data Broker must be started");
+        checkState(baData != null, "Binding Data Broker must be started");
         checkState(baNotifyImpl != null, "Notification Service must be started");
         baBrokerImpl = new DomForwardedBindingBrokerImpl("test");
 
         baBrokerImpl.getMountManager().setDataCommitExecutor(executor);
         baBrokerImpl.getMountManager().setNotificationExecutor(executor);
         baBrokerImpl.setRpcBroker(new RpcProviderRegistryImpl("test"));
-        baBrokerImpl.setDataBroker(baDataImpl);
+        baBrokerImpl.setLegacyDataBroker(baData);
         baBrokerImpl.setNotificationBroker(baNotifyImpl);
         baBrokerImpl.start();
     }
 
     public void startForwarding() {
-        checkState(baDataImpl != null, "Binding Data Broker needs to be started");
-        checkState(biDataImpl != null, "DOM Data Broker needs to be started.");
+        checkState(baData != null, "Binding Data Broker needs to be started");
+        checkState(biDataLegacyBroker != null, "DOM Data Broker needs to be started.");
         checkState(mappingServiceImpl != null, "DOM Mapping Service needs to be started.");
 
         baConnectImpl = BindingDomConnectorDeployer.createConnector(getBindingToDomMappingService());
@@ -160,11 +202,11 @@ public class BindingTestContext implements AutoCloseable, SchemaContextProvider
     }
 
     private ProviderSession createMockContext() {
-        // TODO Auto-generated method stub
+
         final ClassToInstanceMap<BrokerService> domBrokerServices = ImmutableClassToInstanceMap
                 .<BrokerService> builder()
                 //
-                .put(org.opendaylight.controller.sal.core.api.data.DataProviderService.class, biDataImpl) //
+                .put(org.opendaylight.controller.sal.core.api.data.DataProviderService.class, biDataLegacyBroker) //
                 .put(RpcProvisionRegistry.class, biBrokerImpl.getRouter()) //
                 .put(MountProvisionService.class, biMountImpl) //
                 .build();
@@ -172,12 +214,12 @@ public class BindingTestContext implements AutoCloseable, SchemaContextProvider
         return new ProviderSession() {
 
             @Override
-            public Future<RpcResult<CompositeNode>> rpc(QName rpc, CompositeNode input) {
+            public Future<RpcResult<CompositeNode>> rpc(final QName rpc, final CompositeNode input) {
                 throw new UnsupportedOperationException();
             }
 
             @Override
-            public <T extends BrokerService> T getService(Class<T> service) {
+            public <T extends BrokerService> T getService(final Class<T> service) {
                 return domBrokerServices.getInstance(service);
             }
 
@@ -197,23 +239,23 @@ public class BindingTestContext implements AutoCloseable, SchemaContextProvider
 
             @Override
             public ListenerRegistration<RpcRegistrationListener> addRpcRegistrationListener(
-                    RpcRegistrationListener listener) {
+                    final RpcRegistrationListener listener) {
                 return null;
             }
 
             @Override
-            public RpcRegistration addRpcImplementation(QName rpcType, RpcImplementation implementation)
+            public RpcRegistration addRpcImplementation(final QName rpcType, final RpcImplementation implementation)
                     throws IllegalArgumentException {
                 return null;
             }
 
             @Override
-            public RoutedRpcRegistration addRoutedRpcImplementation(QName rpcType, RpcImplementation implementation) {
+            public RoutedRpcRegistration addRoutedRpcImplementation(final QName rpcType, final RpcImplementation implementation) {
                 return null;
             }
 
             @Override
-            public RoutedRpcRegistration addMountedRpcImplementation(QName rpcType, RpcImplementation implementation) {
+            public RoutedRpcRegistration addMountedRpcImplementation(final QName rpcType, final RpcImplementation implementation) {
                 return null;
             }
         };
@@ -221,34 +263,27 @@ public class BindingTestContext implements AutoCloseable, SchemaContextProvider
 
     public void startBindingToDomMappingService() {
         checkState(classPool != null, "ClassPool needs to be present");
-        mappingServiceImpl = new RuntimeGeneratedMappingServiceImpl();
-        mappingServiceImpl.setPool(classPool);
-        mappingServiceImpl.init();
+        mappingServiceImpl = new RuntimeGeneratedMappingServiceImpl(classPool);
+        mockSchemaService.registerSchemaServiceListener(mappingServiceImpl);
     }
 
-    public void updateYangSchema(String[] files) {
-        schemaContext = getContext(files);
-        if (schemaAwareDataStore != null) {
-            schemaAwareDataStore.onGlobalContextUpdated(schemaContext);
-        }
-        if (mappingServiceImpl != null) {
-            mappingServiceImpl.onGlobalContextUpdated(schemaContext);
-        }
+    public void updateYangSchema(final String[] files) {
+        mockSchemaService.changeSchema(getContext(files));
     }
 
     public static String[] getAllYangFilesOnClasspath() {
         Predicate<String> predicate = new Predicate<String>() {
             @Override
-            public boolean apply(String input) {
+            public boolean apply(final String input) {
                 return input.endsWith(".yang");
             }
         };
         Reflections reflection = new Reflections("META-INF.yang", new ResourcesScanner());
         Set<String> result = reflection.getResources(predicate);
-        return (String[]) result.toArray(new String[result.size()]);
+        return result.toArray(new String[result.size()]);
     }
 
-    private static SchemaContext getContext(String[] yangFiles) {
+    private static SchemaContext getContext(final String[] yangFiles) {
         ClassLoader loader = BindingTestContext.class.getClassLoader();
         List<InputStream> streams = new ArrayList<>();
         for (String string : yangFiles) {
@@ -260,7 +295,7 @@ public class BindingTestContext implements AutoCloseable, SchemaContextProvider
         return parser.resolveSchemaContext(modules);
     }
 
-    public void start() {
+    public void startLegacy() {
         startBindingDataBroker();
         startBindingNotificationBroker();
         startBindingBroker();
@@ -275,6 +310,27 @@ public class BindingTestContext implements AutoCloseable, SchemaContextProvider
         }
     }
 
+    public void start() {
+        startNewDomDataBroker();
+        startDomBroker();
+        startDomMountPoint();
+        startBindingToDomMappingService();
+        startNewBindingDataBroker();
+
+        startBindingNotificationBroker();
+        startBindingBroker();
+
+        startForwarding();
+        if (startWithSchema) {
+            loadYangSchemaFromClasspath();
+        }
+    }
+
+    public void startNewBindingDataBroker() {
+        ForwardedBackwardsCompatibleDataBroker forwarded = new ForwardedBackwardsCompatibleDataBroker(newDOMDataBroker, mappingServiceImpl,mockSchemaService, executor);
+        baData = forwarded;
+    }
+
     private void startDomMountPoint() {
         biMountImpl = new MountPointManagerImpl();
         biMountImpl.setDataBroker(getDomDataBroker());
@@ -283,8 +339,8 @@ public class BindingTestContext implements AutoCloseable, SchemaContextProvider
     private void startDomBroker() {
         checkState(executor != null);
         biBrokerImpl = new BrokerImpl();
-        biBrokerImpl.setExecutor(executor);
-        biBrokerImpl.setRouter(new SchemaAwareRpcBroker("/", this));
+        biBrokerImpl.setRouter(new SchemaAwareRpcBroker("/", mockSchemaService));
+
     }
 
     public void startBindingNotificationBroker() {
@@ -299,11 +355,11 @@ public class BindingTestContext implements AutoCloseable, SchemaContextProvider
     }
 
     public DataProviderService getBindingDataBroker() {
-        return baDataImpl;
+        return baData;
     }
 
     public org.opendaylight.controller.sal.core.api.data.DataProviderService getDomDataBroker() {
-        return biDataImpl;
+        return biDataLegacyBroker;
     }
 
     public DataStore getDomDataStore() {
@@ -359,4 +415,6 @@ public class BindingTestContext implements AutoCloseable, SchemaContextProvider
     public MountProvisionService getDomMountProviderService() {
         return biMountImpl;
     }
+
+
 }