auth/auth-cass/src/main/java/org/onap/aaf/auth/dao/CachedDAO.java

   1 /**
   2  * ============LICENSE_START====================================================
   3  * org.onap.aaf
   4  * ===========================================================================
   5  * Copyright (c) 2018 AT&T Intellectual Property. All rights reserved.
   6  * ===========================================================================
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  * ============LICENSE_END====================================================
  19  *
  20  */
  21
  22 package org.onap.aaf.auth.dao;
  23
  24 import java.util.ArrayList;
  25 import java.util.List;
  26
  27 import org.onap.aaf.auth.dao.cass.Status;
  28 import org.onap.aaf.auth.layer.Result;
  29 import org.onap.aaf.misc.env.Trans;
  30
  31 /**
  32  * CachedDAO
  33  *
  34  * Cache the response of "get" of any DAO.
  35  *
  36  * For simplicity's sake, at this time, we only do this for single Object keys
  37  *
  38  * @author Jonathan
  39  *
  40  * @param <DATA>
  41  */
  42 public class CachedDAO<TRANS extends Trans,D extends DAO<TRANS,DATA>,DATA extends Cacheable>
  43                 extends Cached<TRANS,DATA> implements DAO_RO<TRANS,DATA>{
  44 //      private final String dirty_str;
  45
  46         private final D dao;
  47
  48         public CachedDAO(D dao, CIDAO<TRANS> info, int segsize, long expireIn) {
  49                 super(info, dao.table(), segsize, expireIn);
  50
  51                 // Instantiate a new Cache per DAO name (so separate instances use the same cache)
  52                 this.dao = dao;
  53                 //read_str = "Cached READ for " + dao.table();
  54 //              dirty_str = "Cache DIRTY on " + dao.table();
  55                 if(dao instanceof CassDAOImpl) {
  56                         ((CassDAOImpl<?,?>)dao).cache = this;
  57                 }
  58         }
  59
  60         public static<T extends Trans, DA extends DAO<T,DT>, DT extends Cacheable>
  61                         CachedDAO<T,DA,DT> create(DA dao, CIDAO<T> info, int segsize, long expireIn) {
  62                 return new CachedDAO<T,DA,DT>(dao,info, segsize, expireIn);
  63         }
  64
  65         public void add(DATA data)  {
  66                 String key = keyFromObjs(dao.keyFrom(data));
  67                 List<DATA> list = new ArrayList<>();
  68                 list.add(data);
  69                 super.add(key,list);
  70         }
  71
  72 //      public void invalidate(TRANS trans, Object ... objs)  {
  73 //              TimeTaken tt = trans.start(dirty_str, Env.SUB);
  74 //              try {
  75 //                      super.invalidate(keyFromObjs(objs));
  76 //              } finally {
  77 //                      tt.done();
  78 //              }
  79 //      }
  80
  81         public static String keyFromObjs(Object ... objs) {
  82                 String key;
  83                 if(objs.length==1 && objs[0] instanceof String) {
  84                         key = (String)objs[0];
  85                 } else {
  86                         StringBuilder sb = new StringBuilder();
  87                         boolean first = true;
  88                         for(Object o : objs) {
  89                                 if(o!=null) {
  90                                         if(first) {
  91                                             first =false;
  92                                         } else {
  93                                             sb.append('|');
  94                                         }
  95                                         sb.append(o.toString());
  96                                 }
  97                         }
  98                         key = sb.toString();
  99                 }
 100                 return key;
 101         }
 102
 103         public Result<DATA> create(TRANS trans, DATA data) {
 104                 Result<DATA> d = dao.create(trans,data);
 105                 if(d.status==Status.OK) {
 106                     add(d.value);
 107                 } else {
 108                         trans.error().log(d.errorString());
 109                 }
 110                 // dao.create already modifies cache. Do not invalidate again. invalidate(trans,data);
 111                 return d;
 112         }
 113
 114         protected class DAOGetter implements Getter<DATA> {
 115                 protected TRANS trans;
 116                 protected Object objs[];
 117                 protected D dao;
 118                 public Result<List<DATA>> result;
 119
 120                 public DAOGetter(TRANS trans, D dao, Object ... objs) {
 121                         this.trans = trans;
 122                         this.dao = dao;
 123                         this.objs = objs;
 124                 }
 125
 126                 /**
 127                  * Separated into single call for easy overloading
 128                  * @return
 129                  */
 130                 public Result<List<DATA>> call() {
 131                         return dao.read(trans, objs);
 132                 }
 133
 134                 @Override
 135                 public final Result<List<DATA>> get() {
 136                         return call();
 137 //                      if(result.isOKhasData()) { // Note, given above logic, could exist, but stale
 138 //                              return result.value;
 139 //                      } else {
 140 //                              return null;
 141 //                      }
 142                 }
 143         }
 144
 145         @Override
 146         public Result<List<DATA>> read(final TRANS trans, final Object ... objs) {
 147                 DAOGetter getter = new DAOGetter(trans,dao,objs);
 148                 return get(trans, keyFromObjs(objs),getter);
 149 //              if(ld!=null) {
 150 //                      return Result.ok(ld);//.emptyList(ld.isEmpty());
 151 //              }
 152 //              // Result Result if exists
 153 //              if(getter.result==null) {
 154 //                      return Result.err(Status.ERR_NotFound, "No Cache or Lookup found on [%s]",dao.table());
 155 //              }
 156 //              return getter.result;
 157         }
 158
 159         // Slight Improved performance available when String and Obj versions are known.
 160         public Result<List<DATA>> read(final String key, final TRANS trans, final Object[] objs) {
 161                 DAOGetter getter = new DAOGetter(trans,dao,objs);
 162                 return get(trans, key, getter);
 163 //              if(ld!=null) {
 164 //                      return Result.ok(ld);//.emptyList(ld.isEmpty());
 165 //              }
 166 //              // Result Result if exists
 167 //              if(getter.result==null) {
 168 //                      return Result.err(Status.ERR_NotFound, "No Cache or Lookup found on [%s]",dao.table());
 169 //              }
 170 //              return getter.result;
 171         }
 172
 173         @Override
 174         public Result<List<DATA>> read(TRANS trans, DATA data) {
 175                 return read(trans,dao.keyFrom(data));
 176         }
 177         public Result<Void> update(TRANS trans, DATA data) {
 178                 Result<Void> d = dao.update(trans, data);
 179                 if(d.status==Status.OK) {
 180                     add(data);
 181                 } else {
 182                         trans.error().log(d.errorString());
 183                 }
 184                 return d;
 185         }
 186
 187         public Result<Void> delete(TRANS trans, DATA data, boolean reread) {
 188                 if(reread) { // If reread, get from Cache, if possible, not DB exclusively
 189                         Result<List<DATA>> rd = read(trans,data);
 190                         if(rd.notOK()) {
 191                             return Result.err(rd);
 192 //                      } else {
 193 //                              trans.error().log(rd.errorString());
 194                         }
 195                         if(rd.isEmpty()) {
 196                                 data.invalidate(this);
 197                                 return Result.err(Status.ERR_NotFound,"Not Found");
 198                         }
 199                         data = rd.value.get(0);
 200                 }
 201                 Result<Void> rv=dao.delete(trans, data, false);
 202                 data.invalidate(this);
 203                 return rv;
 204         }
 205
 206         @Override
 207         public void close(TRANS trans) {
 208                 if(dao!=null) {
 209                     dao.close(trans);
 210                 }
 211         }
 212
 213
 214         @Override
 215         public String table() {
 216                 return dao.table();
 217         }
 218
 219         public D dao() {
 220                 return dao;
 221         }
 222
 223         public void invalidate(TRANS trans, DATA data) {
 224         if(info.touch(trans, dao.table(),data.invalidate(this)).notOK()) {
 225             trans.error().log("Cannot touch CacheInfo for Role");
 226         }
 227         }
 228 }