@Override public void writeAll(Iterable<? extends Map.Entry<? extends K, ? extends V>> entries) throws BulkCacheWritingException, Exception { delegate.writeAll(entries); }
public void performOperation(CacheLoaderWriter<K, V> cacheLoaderWriter) throws BulkCacheWritingException, Exception { cacheLoaderWriter.writeAll(entries); }
@Override public void writeAll(Iterable<? extends Map.Entry<? extends K, ? extends V>> entries) throws Exception { CacheLoaderWriter.super.writeAll(entries); }
@Override public void writeAll(Iterable<? extends Map.Entry<? extends K, ? extends V>> entries) throws Exception { CacheLoaderWriter.super.writeAll(entries); }
private void cacheLoaderWriterWriteAllCall(Iterable<? extends Map.Entry<? extends K, ? extends V>> entries, Map<K, V> entriesToRemap, Set<K> successes, Map<K, Exception> failures) throws IllegalStateException { Map<K, V> toWrite = new HashMap<>(); for (Map.Entry<? extends K, ? extends V> entry: entries) { V value = entriesToRemap.get(entry.getKey()); if (value == null) { continue; } toWrite.put(entry.getKey(), value); } try { if (! toWrite.isEmpty()) { // write all entries of this batch cacheLoaderWriter.writeAll(toWrite.entrySet()); successes.addAll(toWrite.keySet()); } } catch (BulkCacheWritingException bcwe) { collectSuccessesAndFailures(bcwe, successes, failures); } catch (Exception e) { for (K key: toWrite.keySet()) { failures.put(key, e); } } }
/** * Write all entries to the loader-writer. * * @param entries the entries being put * @param e the triggered failure */ @Override public void putAllFailure(Map<? extends K, ? extends V> entries, StoreAccessException e) { try { loaderWriter.writeAll(entries.entrySet()); // FIXME: bad typing that we should fix } catch(BulkCacheWritingException e1) { throw e1; } catch (Exception e1) { throw ExceptionFactory.newCacheWritingException(e1, e); } finally { cleanup(entries.keySet(), e); } }
@SuppressWarnings({ "rawtypes", "unchecked" }) @Test public void testPutAllWithWriterException() throws Exception { doThrow(new Exception("Mock Exception: cannot write 1")).when(cacheLoaderWriter).writeAll(ArgumentMatchers.<Iterable>any()); Map<Integer, String> values = new HashMap<>(); values.put(1, "one"); values.put(2, "two"); try { testCache.putAll(values); fail("expected CacheWritingException"); } catch (CacheWritingException ex) { // expected } } }
@Test public void putAllFailure() throws Exception { List<MapEntry<Integer, Long>> entryList = Arrays.asList(entry(1, 1L), entry(2, 2L)); Map<Integer, Long> entryMap = entryList.stream().collect(toMap(Map.Entry::getKey, Map.Entry::getValue)); doNothing().when(loaderWriter).writeAll(argThat(containsAllMatcher(entryList))); strategy.putAllFailure(entryMap, accessException); @SuppressWarnings("unchecked") ArgumentCaptor<Iterable<Integer>> captor = ArgumentCaptor.forClass(Iterable.class); verify(store).obliterate(captor.capture()); assertThat(captor.getValue()).contains(1, 2); verify(loaderWriter).writeAll(argThat(containsAllMatcher(entryList))); }
@Test public void putAllFailure_writeAllFailsWithBulkException() throws Exception { List<MapEntry<Integer, Long>> entryList = Arrays.asList(entry(1, 1L), entry(2, 2L)); Map<Integer, Long> entryMap = entryList.stream().collect(toMap(Map.Entry::getKey, Map.Entry::getValue)); doThrow(bulkWritingException).when(loaderWriter).writeAll(argThat(containsAllMatcher(entryList))); assertThatThrownBy(() -> strategy.putAllFailure(entryMap, accessException)) .isSameAs(bulkWritingException); @SuppressWarnings("unchecked") ArgumentCaptor<Iterable<Integer>> captor = ArgumentCaptor.forClass(Iterable.class); verify(store).obliterate(captor.capture()); assertThat(captor.getValue()).contains(1, 2); verify(loaderWriter).writeAll(argThat(containsAllMatcher(entryList))); }
@Test public void putAllFailure_writeAllFailsWithException() throws Exception { List<MapEntry<Integer, Long>> entryList = Arrays.asList(entry(1, 1L), entry(2, 2L)); Map<Integer, Long> entryMap = entryList.stream().collect(toMap(Map.Entry::getKey, Map.Entry::getValue)); doThrow(exception).when(loaderWriter).writeAll(argThat(containsAllMatcher(entryList))); assertThatThrownBy(() -> strategy.putAllFailure(entryMap, accessException)) .isExactlyInstanceOf(CacheWritingException.class) .hasCause(exception); @SuppressWarnings("unchecked") ArgumentCaptor<Iterable<Integer>> captor = ArgumentCaptor.forClass(Iterable.class); verify(store).obliterate(captor.capture()); assertThat(captor.getValue()).contains(1, 2); verify(loaderWriter).writeAll(argThat(containsAllMatcher(entryList))); }
verify(cacheLoaderWriter, times(3)).writeAll(ArgumentMatchers.any(Iterable.class)); Set set = new HashSet(){{add(entry("key0", "value0"));}}; verify(cacheLoaderWriter).writeAll(set); set = new HashSet(){{add(entry("key1", "value1"));}}; verify(cacheLoaderWriter).writeAll(set); set = new HashSet(){{add(entry("key2", "value2"));}}; verify(cacheLoaderWriter).writeAll(set);
@Test public void testPutAll_with_cache_writer_that_throws_exception() throws Exception { CacheConfigurationBuilder cacheConfigurationBuilder = CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class, String.class, heap(100)); CacheLoaderWriterProvider cacheLoaderWriterProvider = mock(CacheLoaderWriterProvider.class); CacheLoaderWriter cacheLoaderWriterThatThrows = mock(CacheLoaderWriter.class); doThrow(new RuntimeException("We should not have called .write() but .writeAll()")).when(cacheLoaderWriterThatThrows).write(ArgumentMatchers .any(), ArgumentMatchers.any()); doThrow(new Exception("Simulating an exception from the cache writer")).when(cacheLoaderWriterThatThrows).writeAll(ArgumentMatchers.any(Iterable.class)); when(cacheLoaderWriterProvider.createCacheLoaderWriter(anyString(), ArgumentMatchers.any(CacheConfiguration.class))).thenReturn(cacheLoaderWriterThatThrows); CacheManagerBuilder<CacheManager> managerBuilder = CacheManagerBuilder.newCacheManagerBuilder().using(cacheLoaderWriterProvider); CacheConfiguration<String, String> cacheConfiguration = cacheConfigurationBuilder.withLoaderWriter(cacheLoaderWriterThatThrows).build(); CacheManager cacheManager = managerBuilder.withCache("myCache", cacheConfiguration).build(true); Cache<String, String> myCache = cacheManager.getCache("myCache", String.class, String.class); HashMap<String, String> stringStringHashMap = new HashMap<>(); for (int i = 0; i < 3; i++) { stringStringHashMap.put("key" + i, "value" + i); } // the call to putAll try { myCache.putAll(stringStringHashMap); fail(); } catch (BulkCacheWritingException bcwe) { assertThat(bcwe.getFailures().size(), is(3)); assertThat(bcwe.getSuccesses().size(), is(0)); } }
gate.acquire(); return null; }).when(loaderWriter).writeAll(any(Iterable.class));
@Override public void writeAll(Iterable<? extends Map.Entry<? extends K, ? extends V>> entries) throws BulkCacheWritingException, Exception { delegate.writeAll(entries); }
public void performOperation(CacheLoaderWriter<K, V> cacheLoaderWriter) throws BulkCacheWritingException, Exception { cacheLoaderWriter.writeAll(entries); }
private void cacheLoaderWriterWriteAllCall(Iterable<? extends Map.Entry<? extends K, ? extends V>> entries, Map<K, V> entriesToRemap, Set<K> successes, Map<K, Exception> failures) throws IllegalStateException { Map<K, V> toWrite = new HashMap<>(); for (Map.Entry<? extends K, ? extends V> entry: entries) { V value = entriesToRemap.get(entry.getKey()); if (value == null) { continue; } toWrite.put(entry.getKey(), value); } try { if (! toWrite.isEmpty()) { // write all entries of this batch cacheLoaderWriter.writeAll(toWrite.entrySet()); successes.addAll(toWrite.keySet()); } } catch (BulkCacheWritingException bcwe) { collectSuccessesAndFailures(bcwe, successes, failures); } catch (Exception e) { for (K key: toWrite.keySet()) { failures.put(key, e); } } }
/** * Write all entries to the loader-writer. * * @param entries the entries being put * @param e the triggered failure */ @Override public void putAllFailure(Map<? extends K, ? extends V> entries, StoreAccessException e) { try { loaderWriter.writeAll(entries.entrySet()); // FIXME: bad typing that we should fix } catch(BulkCacheWritingException e1) { throw e1; } catch (Exception e1) { throw ExceptionFactory.newCacheWritingException(e1, e); } finally { cleanup(entries.keySet(), e); } }