opendaylight/md-sal/sal-akka-raft/src/test/java/org/opendaylight/controller/cluster/raft/utils/InMemorySnapshotStore.java

   1 /*
   2  * Copyright (c) 2015 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
   9 package org.opendaylight.controller.cluster.raft.utils;
  10
  11 import akka.dispatch.Futures;
  12 import akka.japi.Option;
  13 import akka.persistence.SelectedSnapshot;
  14 import akka.persistence.SnapshotMetadata;
  15 import akka.persistence.SnapshotSelectionCriteria;
  16 import akka.persistence.snapshot.japi.SnapshotStore;
  17 import com.google.common.collect.Iterables;
  18 import com.google.common.collect.Lists;
  19 import java.util.ArrayList;
  20 import java.util.Collections;
  21 import java.util.Iterator;
  22 import java.util.List;
  23 import java.util.Map;
  24 import java.util.concurrent.ConcurrentHashMap;
  25 import org.slf4j.Logger;
  26 import org.slf4j.LoggerFactory;
  27 import scala.concurrent.Future;
  28
  29 /**
  30  * An akka SnapshotStore implementation that stores data in memory. This is intended for testing.
  31  *
  32  * @author Thomas Pantelis
  33  */
  34 public class InMemorySnapshotStore extends SnapshotStore {
  35
  36     static final Logger LOG = LoggerFactory.getLogger(InMemorySnapshotStore.class);
  37
  38     private static Map<String, List<StoredSnapshot>> snapshots = new ConcurrentHashMap<>();
  39
  40     public static void addSnapshot(String persistentId, Object snapshot) {
  41         List<StoredSnapshot> snapshotList = snapshots.get(persistentId);
  42
  43         if(snapshotList == null) {
  44             snapshotList = new ArrayList<>();
  45             snapshots.put(persistentId, snapshotList);
  46         }
  47
  48         synchronized (snapshotList) {
  49             snapshotList.add(new StoredSnapshot(new SnapshotMetadata(persistentId, snapshotList.size(),
  50                     System.currentTimeMillis()), snapshot));
  51         }
  52     }
  53
  54     @SuppressWarnings("unchecked")
  55     public static <T> List<T> getSnapshots(String persistentId, Class<T> type) {
  56         List<StoredSnapshot> stored = snapshots.get(persistentId);
  57         if(stored == null) {
  58             return Collections.emptyList();
  59         }
  60
  61         List<T> retList;
  62         synchronized (stored) {
  63             retList = Lists.newArrayListWithCapacity(stored.size());
  64             for(StoredSnapshot s: stored) {
  65                 if(type.isInstance(s.getData())) {
  66                     retList.add((T) s.getData());
  67                 }
  68             }
  69         }
  70
  71         return retList;
  72     }
  73
  74     public static void clear() {
  75         snapshots.clear();
  76     }
  77
  78     @Override
  79     public Future<Option<SelectedSnapshot>> doLoadAsync(String s,
  80         SnapshotSelectionCriteria snapshotSelectionCriteria) {
  81         List<StoredSnapshot> snapshotList = snapshots.get(s);
  82         if(snapshotList == null){
  83             return Futures.successful(Option.<SelectedSnapshot>none());
  84         }
  85
  86         StoredSnapshot snapshot = Iterables.getLast(snapshotList);
  87         SelectedSnapshot selectedSnapshot =
  88             new SelectedSnapshot(snapshot.getMetadata(), snapshot.getData());
  89         return Futures.successful(Option.some(selectedSnapshot));
  90     }
  91
  92     @Override
  93     public Future<Void> doSaveAsync(SnapshotMetadata snapshotMetadata, Object o) {
  94         List<StoredSnapshot> snapshotList = snapshots.get(snapshotMetadata.persistenceId());
  95
  96         if(snapshotList == null){
  97             snapshotList = new ArrayList<>();
  98             snapshots.put(snapshotMetadata.persistenceId(), snapshotList);
  99         }
 100         synchronized (snapshotList) {
 101             snapshotList.add(new StoredSnapshot(snapshotMetadata, o));
 102         }
 103
 104         return Futures.successful(null);
 105     }
 106
 107     @Override
 108     public void onSaved(SnapshotMetadata snapshotMetadata) throws Exception {
 109     }
 110
 111     @Override
 112     public void doDelete(SnapshotMetadata snapshotMetadata) throws Exception {
 113         List<StoredSnapshot> snapshotList = snapshots.get(snapshotMetadata.persistenceId());
 114
 115         if(snapshotList == null){
 116             return;
 117         }
 118
 119         int deleteIndex = -1;
 120
 121         synchronized (snapshotList) {
 122             for(int i=0;i<snapshotList.size(); i++){
 123                 StoredSnapshot snapshot = snapshotList.get(i);
 124                 if(snapshotMetadata.equals(snapshot.getMetadata())){
 125                     deleteIndex = i;
 126                     break;
 127                 }
 128             }
 129
 130             if(deleteIndex != -1){
 131                 snapshotList.remove(deleteIndex);
 132             }
 133         }
 134     }
 135
 136     @Override
 137     public void doDelete(String persistentId, SnapshotSelectionCriteria snapshotSelectionCriteria)
 138         throws Exception {
 139         List<StoredSnapshot> snapshotList = snapshots.get(persistentId);
 140
 141         if(snapshotList == null){
 142             return;
 143         }
 144
 145         synchronized (snapshotList) {
 146             Iterator<StoredSnapshot> iter = snapshotList.iterator();
 147             while(iter.hasNext()) {
 148                 StoredSnapshot s = iter.next();
 149                 LOG.trace("doDelete: sequenceNr: {}, maxSequenceNr: {}", s.getMetadata().sequenceNr(),
 150                         snapshotSelectionCriteria.maxSequenceNr());
 151
 152                 if(s.getMetadata().sequenceNr() <= snapshotSelectionCriteria.maxSequenceNr()) {
 153                     iter.remove();
 154                 }
 155             }
 156         }
 157     }
 158
 159     private static class StoredSnapshot {
 160         private final SnapshotMetadata metadata;
 161         private final Object data;
 162
 163         private StoredSnapshot(SnapshotMetadata metadata, Object data) {
 164             this.metadata = metadata;
 165             this.data = data;
 166         }
 167
 168         public SnapshotMetadata getMetadata() {
 169             return metadata;
 170         }
 171
 172         public Object getData() {
 173             return data;
 174         }
 175     }
 176 }