BUG-1092: adjust to YangInstanceIdentifier
[controller.git] / opendaylight / md-sal / sal-dom-broker / src / main / java / org / opendaylight / controller / sal / dom / broker / impl / SchemaAwareDataStoreAdapter.java
1 /*
2  * Copyright (c) 2014 Cisco 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.sal.dom.broker.impl;
9
10 import static com.google.common.base.Preconditions.checkState;
11
12 import com.google.common.base.Predicate;
13 import com.google.common.collect.FluentIterable;
14 import com.google.common.collect.ImmutableSet;
15 import com.google.common.collect.Iterables;
16
17 import java.util.ArrayList;
18 import java.util.Comparator;
19 import java.util.HashMap;
20 import java.util.List;
21 import java.util.Map;
22 import java.util.Map.Entry;
23 import java.util.concurrent.Future;
24
25 import org.opendaylight.controller.md.sal.common.api.TransactionStatus;
26 import org.opendaylight.controller.md.sal.common.api.data.DataModification;
27 import org.opendaylight.controller.md.sal.common.api.data.DataReader;
28 import org.opendaylight.controller.md.sal.common.impl.AbstractDataModification;
29 import org.opendaylight.controller.md.sal.common.impl.util.AbstractLockableDelegator;
30 import org.opendaylight.controller.sal.core.api.data.DataStore;
31 import org.opendaylight.controller.sal.dom.broker.util.YangDataOperations;
32 import org.opendaylight.controller.sal.dom.broker.util.YangSchemaUtils;
33 import org.opendaylight.yangtools.yang.common.QName;
34 import org.opendaylight.yangtools.yang.common.RpcResult;
35 import org.opendaylight.yangtools.yang.data.api.CompositeNode;
36 import org.opendaylight.yangtools.yang.data.api.YangInstanceIdentifier;
37 import org.opendaylight.yangtools.yang.data.api.Node;
38 import org.opendaylight.yangtools.yang.data.api.SimpleNode;
39 import org.opendaylight.yangtools.yang.data.impl.CompositeNodeTOImpl;
40 import org.opendaylight.yangtools.yang.model.api.ContainerSchemaNode;
41 import org.opendaylight.yangtools.yang.model.api.DataSchemaNode;
42 import org.opendaylight.yangtools.yang.model.api.ListSchemaNode;
43 import org.opendaylight.yangtools.yang.model.api.SchemaContext;
44 import org.opendaylight.yangtools.yang.model.api.SchemaContextListener;
45 import org.slf4j.Logger;
46 import org.slf4j.LoggerFactory;
47
48 public class SchemaAwareDataStoreAdapter extends AbstractLockableDelegator<DataStore> implements //
49 DataStore, //
50 SchemaContextListener, //
51 AutoCloseable {
52
53     private final static Logger LOG = LoggerFactory.getLogger(SchemaAwareDataStoreAdapter.class);
54
55     private SchemaContext schema = null;
56     private boolean validationEnabled = false;
57     private final DataReader<YangInstanceIdentifier, CompositeNode> reader = new MergeFirstLevelReader();
58
59     @Override
60     public boolean containsConfigurationPath(final YangInstanceIdentifier path) {
61         try {
62             getDelegateReadLock().lock();
63             return getDelegate().containsConfigurationPath(path);
64
65         } finally {
66             getDelegateReadLock().unlock();
67         }
68     }
69
70     @Override
71     public boolean containsOperationalPath(final YangInstanceIdentifier path) {
72         try {
73             getDelegateReadLock().lock();
74             return getDelegate().containsOperationalPath(path);
75
76         } finally {
77             getDelegateReadLock().unlock();
78         }
79     }
80
81     @Override
82     public Iterable<YangInstanceIdentifier> getStoredConfigurationPaths() {
83         try {
84             getDelegateReadLock().lock();
85             return getDelegate().getStoredConfigurationPaths();
86
87         } finally {
88             getDelegateReadLock().unlock();
89         }
90     }
91
92     @Override
93     public Iterable<YangInstanceIdentifier> getStoredOperationalPaths() {
94         try {
95             getDelegateReadLock().lock();
96             return getDelegate().getStoredOperationalPaths();
97
98         } finally {
99             getDelegateReadLock().unlock();
100         }
101     }
102
103     @Override
104     public CompositeNode readConfigurationData(final YangInstanceIdentifier path) {
105         return reader.readConfigurationData(path);
106     }
107
108     @Override
109     public CompositeNode readOperationalData(final YangInstanceIdentifier path) {
110         return reader.readOperationalData(path);
111     }
112
113     @Override
114     public org.opendaylight.controller.md.sal.common.api.data.DataCommitHandler.DataCommitTransaction<YangInstanceIdentifier, CompositeNode> requestCommit(
115             final DataModification<YangInstanceIdentifier, CompositeNode> modification) {
116         validateAgainstSchema(modification);
117         NormalizedDataModification cleanedUp = prepareMergedTransaction(modification);
118         cleanedUp.status = TransactionStatus.SUBMITED;
119         return retrieveDelegate().requestCommit(cleanedUp);
120     }
121
122     public boolean isValidationEnabled() {
123         return validationEnabled;
124     }
125
126     public void setValidationEnabled(final boolean validationEnabled) {
127         this.validationEnabled = validationEnabled;
128     }
129
130     private void validateAgainstSchema(final DataModification<YangInstanceIdentifier, CompositeNode> modification) {
131         if (!validationEnabled) {
132             return;
133         }
134
135         if (schema == null) {
136             LOG.warn("Validation not performed for {}. Reason: YANG Schema not present.", modification.getIdentifier());
137             return;
138         }
139     }
140
141     @Override
142     protected void onDelegateChanged(final DataStore oldDelegate, final DataStore newDelegate) {
143         // NOOP
144     }
145
146     @Override
147     public void onGlobalContextUpdated(final SchemaContext context) {
148         this.schema = context;
149     }
150
151     @Override
152     public void close() throws Exception {
153         this.schema = null;
154     }
155
156     protected CompositeNode mergeData(final YangInstanceIdentifier path, final CompositeNode stored, final CompositeNode modified,
157             final boolean config) {
158         // long startTime = System.nanoTime();
159         try {
160             DataSchemaNode node = schemaNodeFor(path);
161             return YangDataOperations.merge(node, stored, modified, config);
162         } finally {
163             // System.out.println("Merge time: " + ((System.nanoTime() -
164             // startTime) / 1000.0d));
165         }
166     }
167
168     private DataSchemaNode schemaNodeFor(final YangInstanceIdentifier path) {
169         checkState(schema != null, "YANG Schema is not available");
170         return YangSchemaUtils.getSchemaNode(schema, path);
171     }
172
173     private NormalizedDataModification prepareMergedTransaction(
174             final DataModification<YangInstanceIdentifier, CompositeNode> original) {
175         NormalizedDataModification normalized = new NormalizedDataModification(original);
176         LOG.trace("Transaction: {} Removed Configuration {}, Removed Operational {}", original.getIdentifier(),
177                 original.getRemovedConfigurationData(), original.getRemovedConfigurationData());
178         LOG.trace("Transaction: {} Created Configuration {}, Created Operational {}", original.getIdentifier(),
179                 original.getCreatedConfigurationData().entrySet(), original.getCreatedOperationalData().entrySet());
180         LOG.trace("Transaction: {} Updated Configuration {}, Updated Operational {}", original.getIdentifier(),
181                 original.getUpdatedConfigurationData().entrySet(), original.getUpdatedOperationalData().entrySet());
182
183         for (YangInstanceIdentifier entry : original.getRemovedConfigurationData()) {
184             normalized.deepRemoveConfigurationData(entry);
185         }
186         for (YangInstanceIdentifier entry : original.getRemovedOperationalData()) {
187             normalized.deepRemoveOperationalData(entry);
188         }
189         for (Entry<YangInstanceIdentifier, CompositeNode> entry : original.getUpdatedConfigurationData().entrySet()) {
190             normalized.putDeepConfigurationData(entry.getKey(), entry.getValue());
191         }
192         for (Entry<YangInstanceIdentifier, CompositeNode> entry : original.getUpdatedOperationalData().entrySet()) {
193             normalized.putDeepOperationalData(entry.getKey(), entry.getValue());
194         }
195         return normalized;
196     }
197
198     private Iterable<YangInstanceIdentifier> getConfigurationSubpaths(final YangInstanceIdentifier entry) {
199         // FIXME: This should be replaced by index
200         Iterable<YangInstanceIdentifier> paths = getStoredConfigurationPaths();
201
202         return getChildrenPaths(entry, paths);
203
204     }
205
206     public Iterable<YangInstanceIdentifier> getOperationalSubpaths(final YangInstanceIdentifier entry) {
207         // FIXME: This should be indexed
208         Iterable<YangInstanceIdentifier> paths = getStoredOperationalPaths();
209
210         return getChildrenPaths(entry, paths);
211     }
212
213     private static final Iterable<YangInstanceIdentifier> getChildrenPaths(final YangInstanceIdentifier entry,
214             final Iterable<YangInstanceIdentifier> paths) {
215         ImmutableSet.Builder<YangInstanceIdentifier> children = ImmutableSet.builder();
216         for (YangInstanceIdentifier potential : paths) {
217             if (entry.contains(potential)) {
218                 children.add(entry);
219             }
220         }
221         return children.build();
222     }
223
224     private final Comparator<Entry<YangInstanceIdentifier, CompositeNode>> preparationComparator = new Comparator<Entry<YangInstanceIdentifier, CompositeNode>>() {
225         @Override
226         public int compare(final Entry<YangInstanceIdentifier, CompositeNode> o1, final Entry<YangInstanceIdentifier, CompositeNode> o2) {
227             YangInstanceIdentifier o1Key = o1.getKey();
228             YangInstanceIdentifier o2Key = o2.getKey();
229             return Integer.compare(o1Key.getPath().size(), o2Key.getPath().size());
230         }
231     };
232
233     private class MergeFirstLevelReader implements DataReader<YangInstanceIdentifier, CompositeNode> {
234
235         @Override
236         public CompositeNode readConfigurationData(final YangInstanceIdentifier path) {
237             getDelegateReadLock().lock();
238             try {
239                 if (Iterables.isEmpty(path.getPathArguments())) {
240                     return null;
241                 }
242                 QName qname = null;
243                 CompositeNode original = getDelegate().readConfigurationData(path);
244                 ArrayList<Node<?>> childNodes = new ArrayList<Node<?>>();
245                 if (original != null) {
246                     childNodes.addAll(original.getValue());
247                     qname = original.getNodeType();
248                 } else {
249                     qname = path.getPath().get(path.getPath().size() - 1).getNodeType();
250                 }
251
252                 FluentIterable<YangInstanceIdentifier> directChildren = FluentIterable.from(getStoredConfigurationPaths())
253                         .filter(new Predicate<YangInstanceIdentifier>() {
254                             @Override
255                             public boolean apply(final YangInstanceIdentifier input) {
256                                 if (path.contains(input)) {
257                                     int nesting = input.getPath().size() - path.getPath().size();
258                                     if (nesting == 1) {
259                                         return true;
260                                     }
261                                 }
262                                 return false;
263                             }
264                         });
265                 for (YangInstanceIdentifier instanceIdentifier : directChildren) {
266                     childNodes.add(getDelegate().readConfigurationData(instanceIdentifier));
267                 }
268                 if (original == null && childNodes.isEmpty()) {
269                     return null;
270                 }
271
272                 return new CompositeNodeTOImpl(qname, null, childNodes);
273             } finally {
274                 getDelegateReadLock().unlock();
275             }
276         }
277
278         @Override
279         public CompositeNode readOperationalData(final YangInstanceIdentifier path) {
280             getDelegateReadLock().lock();
281             try {
282                 if (Iterables.isEmpty(path.getPathArguments())) {
283                     return null;
284                 }
285                 QName qname = null;
286                 CompositeNode original = getDelegate().readOperationalData(path);
287                 ArrayList<Node<?>> childNodes = new ArrayList<Node<?>>();
288                 if (original != null) {
289                     childNodes.addAll(original.getValue());
290                     qname = original.getNodeType();
291                 } else {
292                     qname = path.getPath().get(path.getPath().size() - 1).getNodeType();
293                 }
294
295                 FluentIterable<YangInstanceIdentifier> directChildren = FluentIterable.from(getStoredOperationalPaths())
296                         .filter(new Predicate<YangInstanceIdentifier>() {
297                             @Override
298                             public boolean apply(final YangInstanceIdentifier input) {
299                                 if (path.contains(input)) {
300                                     int nesting = input.getPath().size() - path.getPath().size();
301                                     if (nesting == 1) {
302                                         return true;
303                                     }
304                                 }
305                                 return false;
306                             }
307                         });
308
309                 for (YangInstanceIdentifier instanceIdentifier : directChildren) {
310                     childNodes.add(getDelegate().readOperationalData(instanceIdentifier));
311                 }
312                 if (original == null && childNodes.isEmpty()) {
313                     return null;
314                 }
315
316                 return new CompositeNodeTOImpl(qname, null, childNodes);
317             } finally {
318                 getDelegateReadLock().unlock();
319             }
320         }
321     }
322
323     private class NormalizedDataModification extends AbstractDataModification<YangInstanceIdentifier, CompositeNode> {
324
325         private final String CONFIGURATIONAL_DATA_STORE_MARKER = "configurational";
326         private final String OPERATIONAL_DATA_STORE_MARKER = "operational";
327         private final Object identifier;
328         private TransactionStatus status;
329
330         public NormalizedDataModification(final DataModification<YangInstanceIdentifier, CompositeNode> original) {
331             super(getDelegate());
332             identifier = original;
333             status = TransactionStatus.NEW;
334         }
335
336         /**
337          *
338          * Ensures all subpaths are removed - this currently does slow lookup in
339          * all keys.
340          *
341          * @param entry
342          */
343         public void deepRemoveOperationalData(final YangInstanceIdentifier entry) {
344             Iterable<YangInstanceIdentifier> paths = getOperationalSubpaths(entry);
345             removeOperationalData(entry);
346             for (YangInstanceIdentifier potential : paths) {
347                 removeOperationalData(potential);
348             }
349         }
350
351         public void deepRemoveConfigurationData(final YangInstanceIdentifier entry) {
352             Iterable<YangInstanceIdentifier> paths = getConfigurationSubpaths(entry);
353             removeConfigurationData(entry);
354             for (YangInstanceIdentifier potential : paths) {
355                 removeConfigurationData(potential);
356             }
357         }
358
359         public void putDeepConfigurationData(final YangInstanceIdentifier entryKey, final CompositeNode entryData) {
360             this.putCompositeNodeData(entryKey, entryData, CONFIGURATIONAL_DATA_STORE_MARKER);
361         }
362
363         public void putDeepOperationalData(final YangInstanceIdentifier entryKey, final CompositeNode entryData) {
364             this.putCompositeNodeData(entryKey, entryData, OPERATIONAL_DATA_STORE_MARKER);
365         }
366
367         @Override
368         public Object getIdentifier() {
369             return this.identifier;
370         }
371
372         @Override
373         public TransactionStatus getStatus() {
374             return status;
375         }
376
377         @Override
378         public Future<RpcResult<TransactionStatus>> commit() {
379             throw new UnsupportedOperationException("Commit should not be invoked on this");
380         }
381
382         @Override
383         protected CompositeNode mergeConfigurationData(final YangInstanceIdentifier path, final CompositeNode stored,
384                 final CompositeNode modified) {
385             return mergeData(path, stored, modified, true);
386         }
387
388         @Override
389         protected CompositeNode mergeOperationalData(final YangInstanceIdentifier path, final CompositeNode stored,
390                 final CompositeNode modified) {
391             return mergeData(path, stored, modified, false);
392         }
393
394         private void putData(final YangInstanceIdentifier entryKey, final CompositeNode entryData, final String dataStoreIdentifier) {
395             if (dataStoreIdentifier != null && entryKey != null && entryData != null) {
396                 switch (dataStoreIdentifier) {
397                 case (CONFIGURATIONAL_DATA_STORE_MARKER):
398                     this.putConfigurationData(entryKey, entryData);
399                 break;
400                 case (OPERATIONAL_DATA_STORE_MARKER):
401                     this.putOperationalData(entryKey, entryData);
402                 break;
403
404                 default:
405                     LOG.error(dataStoreIdentifier + " is NOT valid DataStore switch marker");
406                     throw new RuntimeException(dataStoreIdentifier + " is NOT valid DataStore switch marker");
407                 }
408             }
409         }
410
411         private void putCompositeNodeData(final YangInstanceIdentifier entryKey, final CompositeNode entryData,
412                 final String dataStoreIdentifier) {
413             this.putData(entryKey, entryData, dataStoreIdentifier);
414
415             for (Node<?> child : entryData.getValue()) {
416                 YangInstanceIdentifier subEntryId = YangInstanceIdentifier.builder(entryKey).node(child.getNodeType())
417                         .toInstance();
418                 if (child instanceof CompositeNode) {
419                     DataSchemaNode subSchema = schemaNodeFor(subEntryId);
420                     CompositeNode compNode = (CompositeNode) child;
421                     YangInstanceIdentifier instanceId = null;
422
423                     if (subSchema instanceof ListSchemaNode) {
424                         ListSchemaNode listSubSchema = (ListSchemaNode) subSchema;
425                         Map<QName, Object> mapOfSubValues = this.getValuesFromListSchema(listSubSchema,
426                                 (CompositeNode) child);
427                         if (mapOfSubValues != null) {
428                             instanceId = YangInstanceIdentifier.builder(entryKey)
429                                     .nodeWithKey(listSubSchema.getQName(), mapOfSubValues).toInstance();
430                         }
431                     } else if (subSchema instanceof ContainerSchemaNode) {
432                         ContainerSchemaNode containerSchema = (ContainerSchemaNode) subSchema;
433                         instanceId = YangInstanceIdentifier.builder(entryKey).node(subSchema.getQName()).toInstance();
434                     }
435                     if (instanceId != null) {
436                         this.putCompositeNodeData(instanceId, compNode, dataStoreIdentifier);
437                     }
438                 }
439             }
440         }
441
442         private Map<QName, Object> getValuesFromListSchema(final ListSchemaNode listSchema, final CompositeNode entryData) {
443             List<QName> keyDef = listSchema.getKeyDefinition();
444             if (keyDef != null && !keyDef.isEmpty()) {
445                 Map<QName, Object> map = new HashMap<QName, Object>();
446                 for (QName key : keyDef) {
447                     List<Node<?>> data = entryData.get(key);
448                     if (data != null && !data.isEmpty()) {
449                         for (Node<?> nodeData : data) {
450                             if (nodeData instanceof SimpleNode<?>) {
451                                 map.put(key, data.get(0).getValue());
452                             }
453                         }
454                     }
455                 }
456                 return map;
457             }
458             return null;
459         }
460     }
461 }

©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.