gerrit.onap Code Review - ccsdk/features.git/blob

   1 /*
   2  * ============LICENSE_START=======================================================
   3  * ONAP : ccsdk features
   4  * ================================================================================
   5  * Copyright (C) 2019 highstreet technologies GmbH Intellectual Property.
   6  * All rights reserved.
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *     http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END=========================================================
  20  *
  21  */
  22 package org.onap.ccsdk.features.sdnr.wt.dataprovider.database.elasticsearch;
  23
  24 import com.fasterxml.jackson.core.JsonProcessingException;
  25 import java.io.IOException;
  26 import java.lang.reflect.Field;
  27 import java.util.List;
  28 import javax.annotation.Nonnull;
  29 import javax.annotation.Nullable;
  30 import org.eclipse.jdt.annotation.NonNull;
  31 import org.onap.ccsdk.features.sdnr.wt.common.database.DatabaseClient;
  32 import org.onap.ccsdk.features.sdnr.wt.common.database.SearchHit;
  33 import org.onap.ccsdk.features.sdnr.wt.common.database.SearchResult;
  34 import org.onap.ccsdk.features.sdnr.wt.common.database.queries.QueryBuilder;
  35 import org.onap.ccsdk.features.sdnr.wt.yang.mapper.YangToolsMapper2;
  36 import org.onap.ccsdk.features.sdnr.wt.yang.mapper.YangToolsMapperHelper;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.data.provider.rev201110.Entity;
  38 import org.opendaylight.yangtools.concepts.Builder;
  39 import org.opendaylight.yangtools.yang.binding.DataObject;
  40 import org.slf4j.Logger;
  41 import org.slf4j.LoggerFactory;
  42
  43 /**
  44  * Class to rw yang-tool generated objects into elasticsearch database. For "ES _id" exchange the esIdAddAtributteName
  45  * is used. This attribute mast be of type String and contains for read and write operations the object id. The function
  46  * can be used without id handling. If id handling is required the parameter needs to be specified by class definition
  47  * in yang and setting the name by using setAttributeName()
  48  *
  49  * Due to using Jackson base interfaces the org.eclipse.jdt.annotation.NonNull needs to be used here to get rid of
  50  * warnings
  51  *
  52  * @param <T> Yang tools generated class object.
  53  */
  54 public class EsDataObjectReaderWriter2<T extends DataObject> {
  55
  56     private static final Logger LOG = LoggerFactory.getLogger(EsDataObjectReaderWriter2.class);
  57
  58     /** Typename for elastic search data schema **/
  59     private String dataTypeName;
  60
  61     /** Elasticsearch Database client to be used **/
  62     private DatabaseClient db;
  63
  64     /** Mapper with configuration to use opendaylight yang-tools builder pattern for object creation **/
  65     private YangToolsMapper2<T> yangtoolsMapper;
  66
  67     /** Class of T as attribute to allow JSON to Class object mapping **/
  68     private Class<T> clazz;
  69
  70     /** Field is used to write id. If null no id handling **/
  71     private @Nullable Field field;
  72
  73     /** Attribute that is used as id field for the database object **/
  74     private @Nullable String esIdAddAtributteName;
  75
  76     /** Interface to be used for write operations. Rule for write: T extends S and **/
  77     private Class<? extends DataObject> writeInterfaceClazz; // == "S"
  78     /** Flag true to sync this attribute during write always, what is slow and false do not sync */
  79     private final boolean syncAfterWrite;
  80
  81     protected boolean doFullsizeRequest;
  82
  83     /**
  84      * Elasticsearch database read and write for specific class, defined by opendaylight yang-tools.
  85      *
  86      * @param <X>
  87      * @param <B>
  88      * @param db Database access client
  89      * @param dataTypeName typename in database schema
  90      * @param clazz class of type to be handled
  91      * @param builderClazz class to build related object if builder pattern should be used.
  92      * @param syncAfterWrite
  93      * @throws ClassNotFoundException
  94      */
  95     public <X extends T, @NonNull B extends Builder<X>> EsDataObjectReaderWriter2(DatabaseClient db,
  96             String dataTypeName, @Nonnull Class<T> clazz, @Nullable Class<B> builderClazz, boolean syncAfterWrite)
  97             throws ClassNotFoundException {
  98         LOG.info("Create {} for datatype {} class {}", this.getClass().getName(), dataTypeName, clazz.getName());
  99
 100         this.esIdAddAtributteName = null;
 101         this.field = null;
 102         this.writeInterfaceClazz = clazz;
 103         this.db = db;
 104         this.dataTypeName = dataTypeName;
 105         this.yangtoolsMapper = new YangToolsMapper2<>(clazz, builderClazz);
 106         this.clazz = clazz;
 107         this.syncAfterWrite = syncAfterWrite;
 108         this.doFullsizeRequest = false;
 109     }
 110
 111     public void setFullsizeRequest(boolean fullsizeRequest) {
 112         this.doFullsizeRequest = fullsizeRequest;
 113     }
 114     public <X extends T, @NonNull B extends Builder<X>> EsDataObjectReaderWriter2(DatabaseClient db,
 115             Entity dataTypeName, @Nonnull Class<T> clazz, @Nullable Class<B> builderClazz)
 116             throws ClassNotFoundException {
 117         this(db, dataTypeName.getName(), clazz, builderClazz, false);
 118     }
 119
 120     public <X extends T, @NonNull B extends Builder<X>> EsDataObjectReaderWriter2(DatabaseClient db,
 121             Entity dataTypeName, @Nonnull Class<T> clazz, @Nullable Class<B> builderClazz, boolean syncAfterWrite)
 122             throws ClassNotFoundException {
 123         this(db, dataTypeName.getName(), clazz, builderClazz, syncAfterWrite);
 124     }
 125
 126     public EsDataObjectReaderWriter2(DatabaseClient db, Entity dataTypeName, @Nonnull Class<T> clazz,
 127             boolean syncAfterWrite) throws ClassNotFoundException {
 128         this(db, dataTypeName.getName(), clazz, null, syncAfterWrite);
 129     }
 130
 131     public EsDataObjectReaderWriter2(DatabaseClient db, Entity dataTypeName, Class<T> clazz)
 132             throws ClassNotFoundException {
 133         this(db, dataTypeName.getName(), clazz, null, false);
 134     }
 135
 136     /**
 137      * Get Datatype name
 138      *
 139      * @return string with dataTypeName
 140      */
 141     public String getDataTypeName() {
 142         return dataTypeName;
 143     }
 144
 145     /**
 146      * Simlar to {@link #setEsIdAttributeName()}, but adapts the parameter to yangtools attribute naming schema
 147      *
 148      * @param esIdAttributeName is converted to UnderscoreCamelCase
 149      * @return this for further operations.
 150      */
 151     public EsDataObjectReaderWriter2<T> setEsIdAttributeNameCamelized(String esIdAttributeName) {
 152         return setEsIdAttributeName(YangToolsMapperHelper.toCamelCaseAttributeName(esIdAttributeName));
 153     }
 154
 155     /**
 156      * Attribute name of class that is containing the object id
 157      *
 158      * @param esIdAttributeName of the implementation class for the yangtools interface. Expected attribute name format
 159      *        is CamelCase with leading underline. @
 160      * @return this for further operations.
 161      * @throws SecurityException if no access or IllegalArgumentException if wrong type or no attribute with this name.
 162      */
 163     public EsDataObjectReaderWriter2<T> setEsIdAttributeName(String esIdAttributeName) {
 164         LOG.debug("Set attribute '{}'", esIdAttributeName);
 165         this.esIdAddAtributteName = null; // Reset status
 166         this.field = null;
 167
 168         Field attributeField;
 169         try {
 170             Builder<? extends T> builder = yangtoolsMapper.getBuilder(clazz);
 171             if (builder == null) {
 172                 String msg = "No builder for " + clazz;
 173                 LOG.debug(msg);
 174                 throw new IllegalArgumentException(msg);
 175             } else {
 176                 T object = builder.build();
 177                 attributeField = object.getClass().getDeclaredField(esIdAttributeName);
 178                 if (attributeField.getType().equals(String.class)) {
 179                     attributeField.setAccessible(true);
 180                     this.esIdAddAtributteName = esIdAttributeName; // Set new status if everything OK
 181                     this.field = attributeField;
 182                 } else {
 183                     String msg = "Wrong field type " + attributeField.getType().getName() + " of " + esIdAttributeName;
 184                     LOG.debug(msg);
 185                     throw new IllegalArgumentException(msg);
 186                 }
 187             }
 188         } catch (NoSuchFieldException e) {
 189             // Convert to run-time exception
 190             String msg = "NoSuchFieldException for '" + esIdAttributeName + "' in class " + clazz.getName();
 191             LOG.debug(msg);
 192             throw new IllegalArgumentException(msg);
 193         } catch (SecurityException e) {
 194             LOG.debug("Access problem " + esIdAttributeName, e);
 195             throw e;
 196         }
 197         return this;
 198     }
 199
 200     /**
 201      * Specify subclass of T for write operations.
 202      *
 203      * @param writeInterfaceClazz
 204      */
 205     public EsDataObjectReaderWriter2<T> setWriteInterface(Class<? extends DataObject> writeInterfaceClazz) {
 206         LOG.debug("Set write interface to {}", writeInterfaceClazz);
 207         if (writeInterfaceClazz == null) {
 208             throw new IllegalArgumentException("Null not allowed here.");
 209         }
 210
 211         this.writeInterfaceClazz = writeInterfaceClazz;
 212         return this;
 213     }
 214
 215     public interface IdGetter<S extends DataObject> {
 216         String getId(S object);
 217     }
 218
 219     public <S extends DataObject> void write(List<S> objectList, IdGetter<S> idGetter) {
 220         for (S object : objectList) {
 221             write(object, idGetter.getId(object));
 222         }
 223     }
 224
 225     /**
 226      * Write child object to database with specific id
 227      *
 228      * @param object to be written
 229      * @param esId use the id or if null generate unique id
 230      * @return String with id or null
 231      */
 232     public @Nullable <S extends DataObject> String write(S object, @Nullable String esId) {
 233         if (object != null && writeInterfaceClazz.isInstance(object)) {
 234             try {
 235                 String json = yangtoolsMapper.writeValueAsString(object);
 236                 return db.doWriteRaw(dataTypeName, esId, json, this.syncAfterWrite);
 237             } catch (JsonProcessingException e) {
 238                 LOG.error("Write problem: ", e);
 239             }
 240         } else {
 241             LOG.error("Type {} does not provide interface {}", object != null ? object.getClass().getName() : "null",
 242                     writeInterfaceClazz.getName());
 243         }
 244         return null;
 245     }
 246
 247     /**
 248      * Update partial child object to database with match/term query
 249      *
 250      * @param <S> of object
 251      * @param object to write
 252      * @param query for write of specific attributes
 253      * @return json string with new Object
 254      */
 255     public @Nullable <S extends DataObject> boolean update(S object, QueryBuilder query) {
 256         if (object != null && writeInterfaceClazz.isInstance(object)) {
 257             try {
 258                 String json = yangtoolsMapper.writeValueAsString(object);
 259                 return db.doUpdate(this.dataTypeName, json, query);
 260             } catch (JsonProcessingException e) {
 261                 LOG.error("Update problem: ", e);
 262             }
 263         } else {
 264             LOG.error("Type {} does not provide interface {}", object != null ? object.getClass().getName() : "null",
 265                     writeInterfaceClazz.getName());
 266         }
 267         return false;
 268     }
 269
 270     /**
 271      * Write/ update partial child object to database with specific id Write if not exists, else update
 272      *
 273      * @param object
 274      * @param esId
 275      * @return String with esId or null
 276      */
 277     public @Nullable <S extends DataObject> String update(S object, String esId) {
 278         return this.updateOrCreate(object, esId, null);
 279     }
 280
 281     /**
 282      * See {@link doUpdateOrCreate(String dataTypeName, String esId, String json, List<String> doNotUpdateField) }
 283      */
 284     public @Nullable <S extends DataObject> String updateOrCreate(S object, String esId, List<String> onlyForInsert) {
 285         if (object != null && writeInterfaceClazz.isInstance(object)) {
 286             try {
 287                 String json = yangtoolsMapper.writeValueAsString(object);
 288                 return db.doUpdateOrCreate(dataTypeName, esId, json, onlyForInsert);
 289             } catch (JsonProcessingException e) {
 290                 LOG.error("Update problem: ", e);
 291             }
 292         } else {
 293             LOG.error("Type {} does not provide interface {}", object != null ? object.getClass().getName() : "null",
 294                     writeInterfaceClazz.getName());
 295         }
 296         return null;
 297     }
 298
 299     /**
 300      * Read object from database, by using the id field
 301      *
 302      * @param object
 303      * @return
 304      */
 305     public @Nullable T read(String esId) {
 306         @Nullable
 307         T res = null;
 308         if (esId != null) {
 309             String json = db.doReadJsonData(dataTypeName, esId);
 310             if (json != null) {
 311                 try {
 312                     res = yangtoolsMapper.readValue(json.getBytes(), clazz);
 313                 } catch (IOException e) {
 314                     LOG.error("Problem: ", e);
 315                 }
 316             } else {
 317                 LOG.debug("Can not read from DB id {} type {}", esId, dataTypeName);
 318             }
 319         }
 320         return res;
 321     }
 322
 323     /**
 324      * Remove object
 325      *
 326      * @param esId to identify the object.
 327      * @return success
 328      */
 329     public boolean remove(String esId) {
 330         return db.doRemove(this.dataTypeName, esId);
 331     }
 332
 333     public int remove(QueryBuilder query) {
 334         return this.db.doRemove(this.dataTypeName, query);
 335     }
 336
 337     /**
 338      * Get all elements of related type
 339      *
 340      * @return all Elements
 341      */
 342     public SearchResult<T> doReadAll() {
 343         return doReadAll(null);
 344     }
 345
 346     public SearchResult<T> doReadAll(QueryBuilder query) {
 347         return this.doReadAll(query, false);
 348     }
 349
 350     /**
 351      * Read all existing objects of a type
 352      *
 353      * @param query for the elements
 354      * @return the list of all objects
 355      */
 356
 357     public SearchResult<T> doReadAll(QueryBuilder query, boolean ignoreException) {
 358
 359         if(this.doFullsizeRequest) {
 360             query.doFullsizeRequest();
 361         }
 362         SearchResult<T> res = new SearchResult<>();
 363         SearchResult<SearchHit> result;
 364         List<SearchHit> hits;
 365         if (query != null) {
 366             LOG.debug("read data in {} with query {}", dataTypeName, query.toJSON());
 367             result = db.doReadByQueryJsonData(dataTypeName, query, ignoreException);
 368         } else {
 369             result = db.doReadAllJsonData(dataTypeName, ignoreException);
 370         }
 371         hits = result.getHits();
 372         LOG.debug("Read: {} elements: {}", dataTypeName, hits.size());
 373
 374         T object;
 375         for (SearchHit hit : hits) {
 376             object = getT(hit.getSourceAsString());
 377             LOG.debug("Mapp Object: {}\nSource: '{}'\nResult: '{}'\n", hit.getId(),
 378                     hit.getSourceAsString(), object);
 379             if (object != null) {
 380                 setEsId(object, hit.getId());
 381                 res.add(object);
 382             } else {
 383                 LOG.warn("Mapp result null Object: {}\n Source: '{}'\n : '", hit.getId(), hit.getSourceAsString());
 384             }
 385         }
 386         res.setTotal(result.getTotal());
 387         return res;
 388     }
 389
 390     /* ---------------------------------------------
 391      * Private functions
 392      */
 393
 394     private void setEsId(T object, String esId) {
 395         if (field != null) {
 396             try {
 397                 field.set(object, esId);
 398             } catch (IllegalArgumentException | IllegalAccessException e) {
 399                 LOG.debug("Field set problem.", e);
 400             }
 401         }
 402     }
 403
 404     private @Nullable T getT(String jsonString) {
 405         try {
 406             return yangtoolsMapper.readValue(jsonString, clazz);
 407         } catch (IOException e) {
 408             LOG.info("Mapping problem {}:", clazz.getName(), e);
 409             return null;
 410         }
 411     }
 412
 413 }