tests/honeynode/honeynode-common/src/main/java/io/fd/honeycomb/transportpce/test/common/DataStoreContextImpl.java

   1 /*
   2  * Copyright © 2016 AT&T 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 io.fd.honeycomb.transportpce.test.common;
   9
  10 import java.util.LinkedList;
  11 import java.util.List;
  12 import java.util.Optional;
  13 import java.util.ServiceLoader;
  14
  15 import org.opendaylight.controller.md.sal.binding.impl.BindingToNormalizedNodeCodec;
  16 import org.opendaylight.mdsal.binding.generator.impl.GeneratedClassLoadingStrategy;
  17 import org.opendaylight.mdsal.binding.generator.impl.ModuleInfoBackedContext;
  18 import org.opendaylight.mdsal.binding.generator.util.BindingRuntimeContext;
  19 import org.opendaylight.mdsal.binding.generator.util.JavassistUtils;
  20 import org.opendaylight.mdsal.dom.api.DOMSchemaService;
  21 import org.opendaylight.yangtools.binding.data.codec.gen.impl.StreamWriterGenerator;
  22 import org.opendaylight.yangtools.binding.data.codec.impl.BindingNormalizedNodeCodecRegistry;
  23 import org.opendaylight.yangtools.concepts.ListenerRegistration;
  24 import org.opendaylight.yangtools.util.ListenerRegistry;
  25 import org.opendaylight.yangtools.yang.binding.YangModelBindingProvider;
  26 import org.opendaylight.yangtools.yang.binding.YangModuleInfo;
  27 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
  28 import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
  29 import org.opendaylight.yangtools.yang.model.api.SchemaContextProvider;
  30 import org.slf4j.Logger;
  31 import org.slf4j.LoggerFactory;
  32
  33 import javassist.ClassPool;
  34
  35 public class DataStoreContextImpl implements DataStoreContext {
  36
  37     private static final Logger LOG = LoggerFactory.getLogger(DataStoreContextImpl.class);
  38
  39 //    private final Map<LogicalDatastoreType, DOMStore> datastores;
  40     private final SchemaContextHolder mockedSchemaContext;
  41 //    private final DOMNotificationRouter domNotificationRouter;
  42 //    private final DOMDataBroker domDataBroker;
  43 //    private final DataBroker dataBroker;
  44 //    private final NotificationService notificationService;
  45 //    private final NotificationPublishService notificationPublishService;
  46
  47     public DataStoreContextImpl() {
  48         this(false);
  49     }
  50
  51     public DataStoreContextImpl(boolean fromClasspath) {
  52         this.mockedSchemaContext = new SchemaContextHolder(fromClasspath);
  53 //        this.datastores = createDatastores();
  54 //        this.domNotificationRouter = DOMNotificationRouter.create(16);
  55 //        this.domDataBroker = createDOMDataBroker();
  56 //        this.dataBroker = createDataBroker();
  57 //        this.notificationService = createNotificationService();
  58 //        this.notificationPublishService = createNotificationPublishService();
  59 //        for (ListenerRegistration<SchemaContextListener> listener : this.mockedSchemaContext.listeners) {
  60 //            listener.getInstance().onGlobalContextUpdated(this.mockedSchemaContext.schemaContext);
  61 //        }
  62     }
  63
  64 //    @Override
  65 //    public DataBroker getDataBroker() {
  66 //        return this.dataBroker;
  67 //    }
  68 //
  69 //    @Override
  70 //    public DOMDataBroker getDOMDataBroker() {
  71 //        return this.domDataBroker;
  72 //    }
  73 //
  74 //    @Override
  75 //    public NotificationService createNotificationService() {
  76 //        return new BindingDOMNotificationServiceAdapter(this.mockedSchemaContext.bindingStreamCodecs,
  77 //                this.domNotificationRouter);
  78 //    }
  79 //
  80 //    @Override
  81 //    public NotificationPublishService createNotificationPublishService() {
  82 //        return new BindingDOMNotificationPublishServiceAdapter(this.mockedSchemaContext.bindingToNormalized,
  83 //                this.domNotificationRouter);
  84 //    }
  85
  86     @Override
  87     public SchemaContext getSchemaContext() {
  88         return this.mockedSchemaContext.schemaContext;
  89     }
  90
  91     @Override
  92     public BindingNormalizedNodeCodecRegistry getBindingToNormalizedNodeCodec() {
  93         return this.mockedSchemaContext.bindingStreamCodecs;
  94     }
  95
  96 //    @Override
  97 //    public NotificationService getNotificationService() {
  98 //        return this.notificationService;
  99 //    }
 100 //
 101 //    @Override
 102 //    public NotificationPublishService getNotificationPublishService() {
 103 //        return this.notificationPublishService;
 104 //    }
 105 //
 106 //    private DOMDataBroker createDOMDataBroker() {
 107 //        return new SerializedDOMDataBroker(this.datastores,
 108 //                MoreExecutors.listeningDecorator(Executors.newSingleThreadExecutor()));
 109 //    }
 110 //
 111 //    private ListeningExecutorService getDataTreeChangeListenerExecutor() {
 112 //        return MoreExecutors.newDirectExecutorService();
 113 //    }
 114 //
 115 //    private DataBroker createDataBroker() {
 116 //        return new BindingDOMDataBrokerAdapter(getDOMDataBroker(), this.mockedSchemaContext.bindingToNormalized);
 117 //    }
 118 //
 119 //    private Map<LogicalDatastoreType, DOMStore> createDatastores() {
 120 //        return ImmutableMap.<LogicalDatastoreType, DOMStore>builder()
 121 //                .put(LogicalDatastoreType.OPERATIONAL, createOperationalDatastore())
 122 //                .put(LogicalDatastoreType.CONFIGURATION, createConfigurationDatastore()).build();
 123 //    }
 124 //
 125 //    private DOMStore createConfigurationDatastore() {
 126 //        final InMemoryDOMDataStore store = new InMemoryDOMDataStore("CFG", getDataTreeChangeListenerExecutor());
 127 //        this.mockedSchemaContext.registerSchemaContextListener(store);
 128 //        return store;
 129 //    }
 130 //
 131 //    private DOMStore createOperationalDatastore() {
 132 //        final InMemoryDOMDataStore store = new InMemoryDOMDataStore("OPER", getDataTreeChangeListenerExecutor());
 133 //        this.mockedSchemaContext.registerSchemaContextListener(store);
 134 //        return store;
 135 //    }
 136
 137     private class SchemaContextHolder implements DOMSchemaService, SchemaContextProvider {
 138
 139         private final SchemaContext schemaContext;
 140         private final ListenerRegistry<SchemaContextListener> listeners;
 141         private final BindingNormalizedNodeCodecRegistry bindingStreamCodecs;
 142         private final BindingToNormalizedNodeCodec bindingToNormalized;
 143         private final ModuleInfoBackedContext moduleInfoBackedCntxt;
 144
 145         private SchemaContextHolder(boolean fromClasspath) {
 146             List<YangModuleInfo> moduleInfos = loadModuleInfos();
 147             this.moduleInfoBackedCntxt = ModuleInfoBackedContext.create();
 148             this.schemaContext = getSchemaContext(moduleInfos);
 149             this.listeners = ListenerRegistry.create();
 150             this.bindingStreamCodecs = createBindingRegistry();
 151             GeneratedClassLoadingStrategy loading = GeneratedClassLoadingStrategy.getTCCLClassLoadingStrategy();
 152             this.bindingToNormalized = new BindingToNormalizedNodeCodec(loading, this.bindingStreamCodecs);
 153             registerSchemaContextListener(this.bindingToNormalized);
 154         }
 155
 156         @Override
 157         public SchemaContext getSchemaContext() {
 158             return this.schemaContext;
 159         }
 160
 161         /**
 162          * Get the schemacontext from loaded modules on classpath.
 163          *
 164          * @param moduleInfos a list of Yang module Infos
 165          * @return SchemaContext a schema context
 166          */
 167         private SchemaContext getSchemaContext(List<YangModuleInfo> moduleInfos) {
 168             this.moduleInfoBackedCntxt.addModuleInfos(moduleInfos);
 169             Optional<SchemaContext> tryToCreateSchemaContext =
 170                     this.moduleInfoBackedCntxt.tryToCreateSchemaContext().toJavaUtil();
 171             if (!tryToCreateSchemaContext.isPresent()) {
 172                 LOG.error("Could not create the initial schema context. Schema context is empty");
 173                 throw new IllegalStateException();
 174             }
 175             return tryToCreateSchemaContext.get();
 176         }
 177
 178         @Override
 179         public SchemaContext getGlobalContext() {
 180             return this.schemaContext;
 181         }
 182
 183         @Override
 184         public SchemaContext getSessionContext() {
 185             return this.schemaContext;
 186         }
 187
 188         @Override
 189         public ListenerRegistration<SchemaContextListener> registerSchemaContextListener(
 190                 SchemaContextListener listener) {
 191             return this.listeners.register(listener);
 192         }
 193
 194         /**
 195          * Loads all {@link YangModelBindingProvider} on the classpath.
 196          *
 197          * @return list of known {@link YangModuleInfo}
 198          */
 199         private List<YangModuleInfo> loadModuleInfos() {
 200             List<YangModuleInfo> moduleInfos = new LinkedList<>();
 201             ServiceLoader<YangModelBindingProvider> yangProviderLoader =
 202                     ServiceLoader.load(YangModelBindingProvider.class);
 203             for (YangModelBindingProvider yangModelBindingProvider : yangProviderLoader) {
 204                 moduleInfos.add(yangModelBindingProvider.getModuleInfo());
 205                 LOG.debug("Adding [{}] module into known modules", yangModelBindingProvider.getModuleInfo());
 206             }
 207             return moduleInfos;
 208         }
 209
 210         /**
 211          * Creates binding registry.
 212          *
 213          * @return BindingNormalizedNodeCodecRegistry the resulting binding registry
 214          */
 215         private BindingNormalizedNodeCodecRegistry createBindingRegistry() {
 216             BindingRuntimeContext bindingContext = BindingRuntimeContext.create(this.moduleInfoBackedCntxt, this.schemaContext);
 217             BindingNormalizedNodeCodecRegistry bindingNormalizedNodeCodecRegistry =
 218                     new BindingNormalizedNodeCodecRegistry(
 219                             StreamWriterGenerator.create(JavassistUtils.forClassPool(ClassPool.getDefault())));
 220             bindingNormalizedNodeCodecRegistry.onBindingRuntimeContextUpdated(bindingContext);
 221             return bindingNormalizedNodeCodecRegistry;
 222         }
 223     }
 224 }