View Javadoc

1   package net.sf.ehcache.writer;
2   
3   import net.sf.ehcache.CacheEntry;
4   import net.sf.ehcache.CacheException;
5   import net.sf.ehcache.Element;
6   
7   import java.util.Collection;
8   import java.util.HashMap;
9   import java.util.Iterator;
10  import java.util.Map;
11  
12  public class TestCacheWriterRetries extends AbstractTestCacheWriter {
13      private final int retries;
14      private final Map<Object, Element> writtenElements = new HashMap<Object, Element>();
15      private final Map<Object, Integer> retryCount = new HashMap<Object, Integer>();
16      private final Map<Object, Integer> writeCount = new HashMap<Object, Integer>();
17      private final Map<Object, Integer> deleteCount = new HashMap<Object, Integer>();
18  
19      public TestCacheWriterRetries(int retries) {
20          this.retries = retries;
21      }
22  
23      public Map<Object, Element> getWrittenElements() {
24          return writtenElements;
25      }
26  
27      public Map<Object, Integer> getWriteCount() {
28          return writeCount;
29      }
30  
31      public Map<Object, Integer> getDeleteCount() {
32          return deleteCount;
33      }
34  
35      private void failUntilNoMoreRetries(Object key) {
36          int remainingRetries;
37          if (!retryCount.containsKey(key)) {
38              remainingRetries = retries;
39          } else {
40              remainingRetries = retryCount.get(key);
41          }
42          if (remainingRetries-- > 0) {
43              retryCount.put(key, remainingRetries);
44              throw new RuntimeException("Throwing exception to test retries, " + remainingRetries + " remaining for " + key);
45          }
46          retryCount.remove(key);
47      }
48  
49      private void increaseWriteCount(Object key) {
50          if (!writeCount.containsKey(key)) {
51              writeCount.put(key, 1);
52          } else {
53              writeCount.put(key, writeCount.get(key) + 1);
54          }
55      }
56  
57      private void increaseDeleteCount(Object key) {
58          if (!deleteCount.containsKey(key)) {
59              deleteCount.put(key, 1);
60          } else {
61              deleteCount.put(key, deleteCount.get(key) + 1);
62          }
63      }
64  
65      private void put(Object key, Element element) {
66          if (!deleteCount.containsKey(key)) {
67              writtenElements.put(key, element);
68          }
69          increaseWriteCount(key);
70      }
71  
72      @Override
73      public synchronized void write(Element element) throws CacheException {
74          final Object key = element.getObjectKey();
75          failUntilNoMoreRetries(key);
76          put(key, element);
77      }
78  
79      @Override
80      public synchronized void writeAll(Collection<Element> elements) throws CacheException {
81          Iterator<Element> it = elements.iterator();
82          while (it.hasNext()) {
83              Element element = it.next();
84              // fail on the last item in the batch
85              final Object key = element.getObjectKey();
86              if (!it.hasNext()) {
87                  failUntilNoMoreRetries(key);
88              }
89              put(key, element);
90          }
91      }
92  
93      private void remove(Object key) {
94          writtenElements.remove(key);
95          increaseDeleteCount(key);
96      }
97  
98      @Override
99      public synchronized void delete(CacheEntry entry) throws CacheException {
100         Object key = entry.getKey();
101         failUntilNoMoreRetries(key);
102         remove(key);
103     }
104 
105     @Override
106     public synchronized void deleteAll(Collection<CacheEntry> entries) throws CacheException {
107         Iterator<CacheEntry> it = entries.iterator();
108         while (it.hasNext()) {
109             CacheEntry entry = it.next();
110             Object key = entry.getKey();
111             if (!it.hasNext()) {
112                 failUntilNoMoreRetries(key);
113             }
114             remove(key);
115         }
116     }
117 }