Configurable update-strategy for clusteredAppConfig
[controller.git] / opendaylight / blueprint / src / main / java / org / opendaylight / controller / blueprint / ext / DataStoreAppConfigMetadata.java
1 /*
2  * Copyright (c) 2016 Brocade Communications Systems, Inc. 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 org.opendaylight.controller.blueprint.ext;
9
10 import com.google.common.base.Optional;
11 import com.google.common.base.Preconditions;
12 import com.google.common.base.Strings;
13 import com.google.common.util.concurrent.CheckedFuture;
14 import com.google.common.util.concurrent.FutureCallback;
15 import com.google.common.util.concurrent.Futures;
16 import java.io.File;
17 import java.io.FileInputStream;
18 import java.util.Collection;
19 import java.util.Collections;
20 import java.util.List;
21 import java.util.Objects;
22 import java.util.concurrent.atomic.AtomicBoolean;
23 import javax.annotation.Nonnull;
24 import javax.annotation.Nullable;
25 import javax.xml.parsers.DocumentBuilderFactory;
26 import org.apache.aries.blueprint.services.ExtendedBlueprintContainer;
27 import org.opendaylight.controller.md.sal.binding.api.ClusteredDataTreeChangeListener;
28 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
29 import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
30 import org.opendaylight.controller.md.sal.binding.api.DataObjectModification.ModificationType;
31 import org.opendaylight.controller.md.sal.binding.api.DataTreeIdentifier;
32 import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
33 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
34 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
35 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
36 import org.opendaylight.controller.sal.core.api.model.SchemaService;
37 import org.opendaylight.yangtools.binding.data.codec.api.BindingNormalizedNodeSerializer;
38 import org.opendaylight.yangtools.concepts.ListenerRegistration;
39 import org.opendaylight.yangtools.yang.binding.DataObject;
40 import org.opendaylight.yangtools.yang.binding.Identifiable;
41 import org.opendaylight.yangtools.yang.binding.Identifier;
42 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
43 import org.opendaylight.yangtools.yang.binding.util.BindingReflections;
44 import org.opendaylight.yangtools.yang.common.QName;
45 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
46 import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode;
47 import org.opendaylight.yangtools.yang.data.impl.codec.xml.XmlUtils;
48 import org.opendaylight.yangtools.yang.data.impl.schema.ImmutableNodes;
49 import org.opendaylight.yangtools.yang.data.impl.schema.transform.dom.parser.DomToNormalizedNodeParserFactory;
50 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
51 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
52 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
53 import org.opendaylight.yangtools.yang.model.api.Module;
54 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
55 import org.osgi.service.blueprint.container.ComponentDefinitionException;
56 import org.slf4j.Logger;
57 import org.slf4j.LoggerFactory;
58 import org.w3c.dom.Document;
59 import org.w3c.dom.Element;
60
61 /**
62  * Factory metadata corresponding to the "clustered-app-config" element that obtains an application's
63  * config data from the data store and provides the binding DataObject instance to the Blueprint container
64  * as a bean. In addition registers a DataTreeChangeListener to restart the Blueprint container when the
65  * config data is changed.
66  *
67  * @author Thomas Pantelis
68  */
69 public class DataStoreAppConfigMetadata extends AbstractDependentComponentFactoryMetadata {
70     private static final Logger LOG = LoggerFactory.getLogger(DataStoreAppConfigMetadata.class);
71
72     static final String BINDING_CLASS = "binding-class";
73     static final String DEFAULT_CONFIG = "default-config";
74     static final String DEFAULT_CONFIG_FILE_NAME = "default-config-file-name";
75     static final String LIST_KEY_VALUE = "list-key-value";
76
77     private static final String DEFAULT_APP_CONFIG_FILE_PATH = "etc" + File.separator +
78             "opendaylight" + File.separator + "datastore" + File.separator + "initial" +
79             File.separator + "config";
80
81     private static final DocumentBuilderFactory DOC_BUILDER_FACTORY;
82
83     static {
84         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
85         factory.setNamespaceAware(true);
86         factory.setCoalescing(true);
87         factory.setIgnoringElementContentWhitespace(true);
88         factory.setIgnoringComments(true);
89         DOC_BUILDER_FACTORY = factory;
90     }
91
92     private final Element defaultAppConfigElement;
93     private final String defaultAppConfigFileName;
94     private final String appConfigBindingClassName;
95     private final String appConfigListKeyValue;
96     private final UpdateStrategy appConfigUpdateStrategy;
97     private final AtomicBoolean readingInitialAppConfig = new AtomicBoolean(true);
98
99     private volatile BindingContext bindingContext;
100     private volatile ListenerRegistration<?> appConfigChangeListenerReg;
101     private volatile DataObject currentAppConfig;
102
103     // Note: the BindingNormalizedNodeSerializer interface is annotated as deprecated because there's an
104     // equivalent interface in the mdsal project but the corresponding binding classes in the controller
105     // project are still used - conversion to the mdsal binding classes hasn't occurred yet.
106     private volatile BindingNormalizedNodeSerializer bindingSerializer;
107
108     public DataStoreAppConfigMetadata(@Nonnull String id, @Nonnull String appConfigBindingClassName,
109             @Nullable String appConfigListKeyValue, @Nullable String defaultAppConfigFileName,
110             @Nonnull UpdateStrategy updateStrategyValue, @Nullable Element defaultAppConfigElement) {
111         super(id);
112         this.defaultAppConfigElement = defaultAppConfigElement;
113         this.defaultAppConfigFileName = defaultAppConfigFileName;
114         this.appConfigBindingClassName = appConfigBindingClassName;
115         this.appConfigListKeyValue = appConfigListKeyValue;
116         this.appConfigUpdateStrategy = updateStrategyValue;
117     }
118
119     @Override
120     @SuppressWarnings("unchecked")
121     public void init(ExtendedBlueprintContainer container) {
122         super.init(container);
123
124         Class<DataObject> appConfigBindingClass;
125         try {
126             Class<?> bindingClass = container.getBundleContext().getBundle().loadClass(appConfigBindingClassName);
127             if(!DataObject.class.isAssignableFrom(bindingClass)) {
128                 throw new ComponentDefinitionException(String.format(
129                         "%s: Specified app config binding class %s does not extend %s",
130                         logName(), appConfigBindingClassName, DataObject.class.getName()));
131             }
132
133             appConfigBindingClass = (Class<DataObject>) bindingClass;
134         } catch(ClassNotFoundException e) {
135             throw new ComponentDefinitionException(String.format("%s: Error loading app config binding class %s",
136                     logName(), appConfigBindingClassName), e);
137         }
138
139         if(Identifiable.class.isAssignableFrom(appConfigBindingClass)) {
140             // The binding class corresponds to a yang list.
141             if(Strings.isNullOrEmpty(appConfigListKeyValue)) {
142                 throw new ComponentDefinitionException(String.format(
143                         "%s: App config binding class %s represents a yang list therefore \"%s\" must be specified",
144                         logName(), appConfigBindingClassName, LIST_KEY_VALUE));
145             }
146
147             try {
148                 bindingContext = ListBindingContext.newInstance(appConfigBindingClass, appConfigListKeyValue);
149             } catch(Exception e) {
150                 throw new ComponentDefinitionException(String.format(
151                         "%s: Error initializing for app config list binding class %s",
152                         logName(), appConfigBindingClassName), e);
153             }
154
155         } else {
156             bindingContext = new ContainerBindingContext(appConfigBindingClass);
157         }
158     }
159
160     @Override
161     public Object create() throws ComponentDefinitionException {
162         LOG.debug("{}: In create - currentAppConfig: {}", logName(), currentAppConfig);
163
164         super.onCreate();
165
166         return currentAppConfig;
167     }
168
169     @Override
170     protected void startTracking() {
171         // First get the BindingNormalizedNodeSerializer OSGi service. This will be used to create a default
172         // instance of the app config binding class, if necessary.
173
174         retrieveService("binding-codec", BindingNormalizedNodeSerializer.class, service -> {
175             bindingSerializer = (BindingNormalizedNodeSerializer)service;
176             retrieveDataBrokerService();
177         });
178     }
179
180     private void retrieveDataBrokerService() {
181         LOG.debug("{}: In retrieveDataBrokerService", logName());
182
183         // Get the binding DataBroker OSGi service.
184
185         retrieveService("data-broker", DataBroker.class, service -> retrieveInitialAppConfig((DataBroker)service));
186     }
187
188     private void retrieveInitialAppConfig(DataBroker dataBroker) {
189         LOG.debug("{}: Got DataBroker instance - reading app config {}", logName(), bindingContext.appConfigPath);
190
191         setDependendencyDesc("Initial app config " + bindingContext.appConfigBindingClass.getSimpleName());
192
193         // We register a DTCL to get updates and also read the app config data from the data store. If
194         // the app config data is present then both the read and initial DTCN update will return it. If the
195         // the data isn't present, we won't get an initial DTCN update so the read will indicate the data
196         // isn't present.
197
198         DataTreeIdentifier<DataObject> dataTreeId = new DataTreeIdentifier<>(LogicalDatastoreType.CONFIGURATION,
199                 bindingContext.appConfigPath);
200         appConfigChangeListenerReg = dataBroker.registerDataTreeChangeListener(dataTreeId,
201                 new ClusteredDataTreeChangeListener<DataObject>() {
202                     @Override
203                     public void onDataTreeChanged(Collection<DataTreeModification<DataObject>> changes) {
204                         onAppConfigChanged(changes);
205                     }
206                 });
207
208         readInitialAppConfig(dataBroker);
209     }
210
211     private void readInitialAppConfig(final DataBroker dataBroker) {
212
213         final ReadOnlyTransaction readOnlyTx = dataBroker.newReadOnlyTransaction();
214         CheckedFuture<Optional<DataObject>, ReadFailedException> future = readOnlyTx.read(
215                 LogicalDatastoreType.CONFIGURATION, bindingContext.appConfigPath);
216         Futures.addCallback(future, new FutureCallback<Optional<DataObject>>() {
217             @Override
218             public void onSuccess(Optional<DataObject> possibleAppConfig) {
219                 LOG.debug("{}: Read of app config {} succeeded: {}", logName(), bindingContext.appConfigBindingClass.getName(),
220                         possibleAppConfig);
221
222                 readOnlyTx.close();
223                 setInitialAppConfig(possibleAppConfig);
224             }
225
226             @Override
227             public void onFailure(Throwable t) {
228                 readOnlyTx.close();
229
230                 // We may have gotten the app config via the data tree change listener so only retry if not.
231                 if(readingInitialAppConfig.get()) {
232                     LOG.warn("{}: Read of app config {} failed - retrying", logName(),
233                             bindingContext.appConfigBindingClass.getName(), t);
234
235                     readInitialAppConfig(dataBroker);
236                 }
237             }
238         });
239     }
240
241     private void onAppConfigChanged(Collection<DataTreeModification<DataObject>> changes) {
242         for(DataTreeModification<DataObject> change: changes) {
243             DataObjectModification<DataObject> changeRoot = change.getRootNode();
244             ModificationType type = changeRoot.getModificationType();
245
246             LOG.debug("{}: onAppConfigChanged: {}, {}", logName(), type, change.getRootPath());
247
248             if(type == ModificationType.SUBTREE_MODIFIED || type == ModificationType.WRITE) {
249                 DataObject newAppConfig = changeRoot.getDataAfter();
250
251                 LOG.debug("New app config instance: {}, previous: {}", newAppConfig, currentAppConfig);
252
253                 if(!setInitialAppConfig(Optional.of(newAppConfig)) &&
254                         !Objects.equals(currentAppConfig, newAppConfig)) {
255                     LOG.debug("App config was updated");
256
257                     if(appConfigUpdateStrategy == UpdateStrategy.RELOAD) {
258                         restartContainer();
259                     }
260                 }
261             } else if(type == ModificationType.DELETE) {
262                 LOG.debug("App config was deleted");
263
264                 if(appConfigUpdateStrategy == UpdateStrategy.RELOAD) {
265                     restartContainer();
266                 }
267             }
268         }
269     }
270
271     private boolean setInitialAppConfig(Optional<DataObject> possibleAppConfig) {
272         boolean result = readingInitialAppConfig.compareAndSet(true, false);
273         if(result) {
274             DataObject localAppConfig;
275             if(possibleAppConfig.isPresent()) {
276                 localAppConfig = possibleAppConfig.get();
277             } else {
278                 // No app config data is present so create an empty instance via the bindingSerializer service.
279                 // This will also return default values for leafs that haven't been explicitly set.
280                 localAppConfig = createDefaultInstance();
281             }
282
283             LOG.debug("{}: Setting currentAppConfig instance: {}", logName(), localAppConfig);
284
285             // Now publish the app config instance to the volatile field and notify the callback to let the
286             // container know our dependency is now satisfied.
287             currentAppConfig = localAppConfig;
288             setSatisfied();
289         }
290
291         return result;
292     }
293
294     private DataObject createDefaultInstance() {
295         YangInstanceIdentifier yangPath = bindingSerializer.toYangInstanceIdentifier(bindingContext.appConfigPath);
296
297         LOG.debug("{}: Creating app config instance from path {}, Qname: {}", logName(), yangPath, bindingContext.bindingQName);
298
299         SchemaService schemaService = getOSGiService(SchemaService.class);
300         if(schemaService == null) {
301             setFailureMessage(String.format("%s: Could not obtain the SchemaService OSGi service", logName()));
302             return null;
303         }
304
305         SchemaContext schemaContext = schemaService.getGlobalContext();
306
307         Module module = schemaContext.findModuleByNamespaceAndRevision(bindingContext.bindingQName.getNamespace(),
308                 bindingContext.bindingQName.getRevision());
309         if(module == null) {
310             setFailureMessage(String.format("%s: Could not obtain the module schema for namespace %s, revision %s",
311                     logName(), bindingContext.bindingQName.getNamespace(), bindingContext.bindingQName.getRevision()));
312             return null;
313         }
314
315         DataSchemaNode dataSchema = module.getDataChildByName(bindingContext.bindingQName);
316         if(dataSchema == null) {
317             setFailureMessage(String.format("%s: Could not obtain the schema for %s", logName(), bindingContext.bindingQName));
318             return null;
319         }
320
321         if(!bindingContext.schemaType.isAssignableFrom(dataSchema.getClass())) {
322             setFailureMessage(String.format("%s: Expected schema type %s for %s but actual type is %s", logName(),
323                     bindingContext.schemaType, bindingContext.bindingQName, dataSchema.getClass()));
324             return null;
325         }
326
327         NormalizedNode<?, ?> dataNode = parsePossibleDefaultAppConfigXMLFile(schemaContext, dataSchema);
328         if(dataNode == null) {
329             dataNode = parsePossibleDefaultAppConfigElement(schemaContext, dataSchema);
330         }
331
332         if(dataNode == null) {
333             dataNode = bindingContext.newDefaultNode(dataSchema);
334         }
335
336         DataObject appConfig = bindingSerializer.fromNormalizedNode(yangPath, dataNode).getValue();
337
338         if(appConfig == null) {
339             // This shouldn't happen but need to handle it in case...
340             setFailureMessage(String.format("%s: Could not create instance for app config binding %s",
341                     logName(), bindingContext.appConfigBindingClass));
342         }
343
344         return appConfig;
345     }
346
347     private NormalizedNode<?, ?> parsePossibleDefaultAppConfigXMLFile(SchemaContext schemaContext,
348             DataSchemaNode dataSchema) {
349
350         String appConfigFileName = defaultAppConfigFileName;
351         if(Strings.isNullOrEmpty(appConfigFileName)) {
352             String moduleName = findYangModuleName(bindingContext.bindingQName, schemaContext);
353             if(moduleName == null) {
354                 return null;
355             }
356
357             appConfigFileName = moduleName + "_" + bindingContext.bindingQName.getLocalName() + ".xml";
358         }
359
360         File appConfigFile = new File(DEFAULT_APP_CONFIG_FILE_PATH, appConfigFileName);
361
362         LOG.debug("{}: parsePossibleDefaultAppConfigXMLFile looking for file {}", logName(),
363                 appConfigFile.getAbsolutePath());
364
365         if(!appConfigFile.exists()) {
366             return null;
367         }
368
369         LOG.debug("{}: Found file {}", logName(), appConfigFile.getAbsolutePath());
370
371         DomToNormalizedNodeParserFactory parserFactory = DomToNormalizedNodeParserFactory.getInstance(
372                 XmlUtils.DEFAULT_XML_CODEC_PROVIDER, schemaContext);
373
374         try(FileInputStream fis = new FileInputStream(appConfigFile)) {
375             Document root = DOC_BUILDER_FACTORY.newDocumentBuilder().parse(fis);
376             NormalizedNode<?, ?> dataNode = bindingContext.parseDataElement(root.getDocumentElement(), dataSchema,
377                     parserFactory);
378
379             LOG.debug("{}: Parsed data node: {}", logName(), dataNode);
380
381             return dataNode;
382         } catch (Exception e) {
383             setFailureMessage(String.format("%s: Could not read/parse app config file %s", logName(), appConfigFile));
384         }
385
386         return null;
387     }
388
389     private String findYangModuleName(QName qname, SchemaContext schemaContext) {
390         for(Module m: schemaContext.getModules()) {
391             if(qname.getModule().equals(m.getQNameModule())) {
392                 return m.getName();
393             }
394         }
395
396         setFailureMessage(String.format("%s: Could not find yang module for QName %s", logName(), qname));
397         return null;
398     }
399
400     @Nullable
401     private NormalizedNode<?, ?> parsePossibleDefaultAppConfigElement(SchemaContext schemaContext,
402             DataSchemaNode dataSchema) {
403         if(defaultAppConfigElement == null) {
404             return null;
405         }
406
407         LOG.debug("{}: parsePossibleDefaultAppConfigElement for {}", logName(), bindingContext.bindingQName);
408
409         DomToNormalizedNodeParserFactory parserFactory = DomToNormalizedNodeParserFactory.getInstance(
410                 XmlUtils.DEFAULT_XML_CODEC_PROVIDER, schemaContext);
411
412
413         LOG.debug("{}: Got app config schema: {}", logName(), dataSchema);
414
415         NormalizedNode<?, ?> dataNode = bindingContext.parseDataElement(defaultAppConfigElement, dataSchema,
416                 parserFactory);
417
418         LOG.debug("{}: Parsed data node: {}", logName(), dataNode);
419
420         return dataNode;
421     }
422
423
424     @Override
425     public void destroy(Object instance) {
426         super.destroy(instance);
427
428         if(appConfigChangeListenerReg != null) {
429             appConfigChangeListenerReg.close();
430             appConfigChangeListenerReg = null;
431         }
432     }
433
434     /**
435      * Internal base class to abstract binding type-specific behavior.
436      */
437     private static abstract class BindingContext {
438         final InstanceIdentifier<DataObject> appConfigPath;
439         final Class<DataObject> appConfigBindingClass;
440         final Class<? extends DataSchemaNode> schemaType;
441         final QName bindingQName;
442
443         protected BindingContext(Class<DataObject> appConfigBindingClass, InstanceIdentifier<DataObject> appConfigPath,
444                 Class<? extends DataSchemaNode> schemaType) {
445             this.appConfigBindingClass = appConfigBindingClass;
446             this.appConfigPath = appConfigPath;
447             this.schemaType = schemaType;
448
449             bindingQName = BindingReflections.findQName(appConfigBindingClass);
450         }
451
452         abstract NormalizedNode<?, ?> parseDataElement(Element element, DataSchemaNode dataSchema,
453                 DomToNormalizedNodeParserFactory parserFactory);
454
455         abstract NormalizedNode<?, ?> newDefaultNode(DataSchemaNode dataSchema);
456     }
457
458     /**
459      * BindingContext implementation for a container binding.
460      */
461     private static class ContainerBindingContext extends BindingContext {
462         ContainerBindingContext(Class<DataObject> appConfigBindingClass) {
463             super(appConfigBindingClass, InstanceIdentifier.create(appConfigBindingClass), ContainerSchemaNode.class);
464         }
465
466         @Override
467         NormalizedNode<?, ?> newDefaultNode(DataSchemaNode dataSchema) {
468             return ImmutableNodes.containerNode(bindingQName);
469         }
470
471         @Override
472         NormalizedNode<?, ?> parseDataElement(Element element, DataSchemaNode dataSchema,
473                 DomToNormalizedNodeParserFactory parserFactory) {
474             return parserFactory.getContainerNodeParser().parse(Collections.singletonList(element),
475                     (ContainerSchemaNode)dataSchema);
476         }
477     }
478
479     /**
480      * BindingContext implementation for a list binding.
481      */
482     private static class ListBindingContext extends BindingContext {
483         final String appConfigListKeyValue;
484
485         ListBindingContext(Class<DataObject> appConfigBindingClass, InstanceIdentifier<DataObject> appConfigPath,
486                 String appConfigListKeyValue) {
487             super(appConfigBindingClass, appConfigPath, ListSchemaNode.class);
488             this.appConfigListKeyValue = appConfigListKeyValue;
489         }
490
491         @SuppressWarnings({ "rawtypes", "unchecked" })
492         private static ListBindingContext newInstance(Class<DataObject> bindingClass, String listKeyValue)
493                 throws Exception {
494             // We assume the yang list key type is string.
495             Identifier keyInstance = (Identifier) bindingClass.getMethod("getKey").getReturnType().
496                     getConstructor(String.class).newInstance(listKeyValue);
497             InstanceIdentifier appConfigPath = InstanceIdentifier.builder((Class)bindingClass, keyInstance).build();
498             return new ListBindingContext(bindingClass, appConfigPath, listKeyValue);
499         }
500
501         @Override
502         NormalizedNode<?, ?> newDefaultNode(DataSchemaNode dataSchema) {
503             // We assume there's only one key for the list.
504             List<QName> keys = ((ListSchemaNode)dataSchema).getKeyDefinition();
505             Preconditions.checkArgument(keys.size() == 1, "Expected only 1 key for list %s", appConfigBindingClass);
506             QName listKeyQName = keys.iterator().next();
507             return ImmutableNodes.mapEntryBuilder(bindingQName, listKeyQName, appConfigListKeyValue).build();
508         }
509
510         @Override
511         NormalizedNode<?, ?> parseDataElement(Element element, DataSchemaNode dataSchema,
512                 DomToNormalizedNodeParserFactory parserFactory) {
513             return parserFactory.getMapEntryNodeParser().parse(Collections.singletonList(element),
514                     (ListSchemaNode)dataSchema);
515         }
516     }
517 }

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.