@Override public Map<K, V> loadAll(Iterable<? extends K> keys) throws BulkCacheLoadingException, Exception { return delegate.loadAll(keys); }
@Override public Map<K, V> loadAllAlways(Iterable<? extends K> keys) throws BulkCacheLoadingException, Exception { return delegate.loadAll(keys); }
@Override public synchronized Map<K, V> loadAll(Iterable<? extends K> keys) throws Exception { return CacheLoaderWriter.super.loadAll(keys); }
@Override public synchronized Map<K, V> loadAll(Iterable<? extends K> keys) throws Exception { return CacheLoaderWriter.super.loadAll(keys); }
/** * Get all entries for the provided keys. Entries not found by the loader-writer are expected to be an entry * with the key and a null value. * * @param keys the keys being retrieved * @param e the triggered failure * @return a map of key-value pairs as loaded by the loader-writer */ @SuppressWarnings("unchecked") @Override public Map<K, V> getAllFailure(Iterable<? extends K> keys, StoreAccessException e) { try { return loaderWriter.loadAll((Iterable) keys); // FIXME: bad typing that we should fix } catch(BulkCacheLoadingException e1) { throw e1; } catch (Exception e1) { throw ExceptionFactory.newCacheLoadingException(e1, e); } finally { cleanup(keys, e); } }
Map<? super K, ? extends V> loaded; try { loaded = cacheLoaderWriter.loadAll(keys1); } catch(BulkCacheLoadingException bcle) { loaded = Collections.emptyMap();
@Test public void getAllFailure_allFound() throws Exception { List<Integer> keys = Arrays.asList(1, 2); Map<Integer, Long> entries = keys.stream().collect(toMap(identity(), k -> (long) k)); when(loaderWriter.loadAll(keys)).thenReturn(entries); assertThat(strategy.getAllFailure(keys, accessException)).isEqualTo(entries); @SuppressWarnings("unchecked") ArgumentCaptor<Iterable<Integer>> captor = ArgumentCaptor.forClass(Iterable.class); verify(store).obliterate(captor.capture()); assertThat(captor.getValue()).contains(1, 2); verify(loaderWriter).loadAll(keys); }
@Test public void getAllFailure_nothingFound() throws Exception { List<Integer> keys = Arrays.asList(1, 2); Map<Integer, Long> entries = new HashMap<>(); keys.forEach(k -> entries.put(k, null)); when(loaderWriter.loadAll(keys)).thenReturn(entries); assertThat(strategy.getAllFailure(keys, accessException)).isEqualTo(entries); @SuppressWarnings("unchecked") ArgumentCaptor<Iterable<Integer>> captor = ArgumentCaptor.forClass(Iterable.class); verify(store).obliterate(captor.capture()); assertThat(captor.getValue()).contains(1, 2); verify(loaderWriter).loadAll(keys); }
@Test public void getAllFailure_loadFailsWithBulkException() throws Exception { List<Integer> keys = Arrays.asList(1, 2); when(loaderWriter.loadAll(keys)).thenThrow(bulkLoadingException); assertThatThrownBy(() -> strategy.getAllFailure(keys, accessException)) .isSameAs(bulkLoadingException); @SuppressWarnings("unchecked") ArgumentCaptor<Iterable<Integer>> captor = ArgumentCaptor.forClass(Iterable.class); verify(store).obliterate(captor.capture()); assertThat(captor.getValue()).contains(1, 2); verify(loaderWriter).loadAll(keys); }
@Test public void getAllFailure_partialFound() throws Exception { List<Integer> keys = Arrays.asList(1, 2); Map<Integer, Long> entries = new HashMap<>(); keys.forEach(k -> entries.put(k, k == 2 ? null : (long) k)); when(loaderWriter.loadAll(keys)).thenReturn(entries); assertThat(strategy.getAllFailure(keys, accessException)).isEqualTo(entries); @SuppressWarnings("unchecked") ArgumentCaptor<Iterable<Integer>> captor = ArgumentCaptor.forClass(Iterable.class); verify(store).obliterate(captor.capture()); assertThat(captor.getValue()).contains(1, 2); verify(loaderWriter).loadAll(keys); }
@Test public void getAllFailure_loadFailsWithException() throws Exception { List<Integer> keys = Arrays.asList(1, 2); when(loaderWriter.loadAll(keys)).thenThrow(exception); assertThatThrownBy(() -> strategy.getAllFailure(keys, accessException)) .isExactlyInstanceOf(CacheLoadingException.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).loadAll(keys); }
@Test public void testGetAllWithLoaderException() throws Exception { when(cacheLoaderWriter.loadAll(ArgumentMatchers.<Iterable<Number>>any())).thenAnswer(invocation -> { @SuppressWarnings("unchecked") Iterable<Integer> iterable = (Iterable<Integer>) invocation.getArguments()[0];
@Test public void testGetAll_with_cache_loader() throws Exception { CacheConfigurationBuilder cacheConfigurationBuilder = CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class, String.class, heap(100)); CacheLoaderWriterProvider cacheLoaderWriterProvider = mock(CacheLoaderWriterProvider.class); CacheLoaderWriter cacheLoaderWriter = mock(CacheLoaderWriter.class); when(cacheLoaderWriter.load(ArgumentMatchers.any())).thenThrow(new RuntimeException("We should not have called .load() but .loadAll()")); when(cacheLoaderWriterProvider.createCacheLoaderWriter(anyString(), ArgumentMatchers.any(CacheConfiguration.class))).thenReturn(cacheLoaderWriter); CacheManagerBuilder<CacheManager> managerBuilder = CacheManagerBuilder.newCacheManagerBuilder().using(cacheLoaderWriterProvider); CacheConfiguration<String, String> cacheConfiguration = cacheConfigurationBuilder.withLoaderWriter(cacheLoaderWriter).build(); CacheManager cacheManager = managerBuilder.withCache("myCache", cacheConfiguration).build(true); when(cacheLoaderWriter.loadAll(argThat(IsCollectionContaining.<String>hasItem("key0")))).thenReturn(new HashMap(){{put("key0","value0");}}); when(cacheLoaderWriter.loadAll(argThat(IsCollectionContaining.<String>hasItem("key2")))).thenReturn(new HashMap(){{put("key2","value2");}}); Cache<String, String> myCache = cacheManager.getCache("myCache", String.class, String.class); Set<String> fewKeysSet = new HashSet<String>() { { add("key0"); add("key2"); } }; // the call to getAll Map<String, String> fewEntries = myCache.getAll(fewKeysSet); assertThat(fewEntries.size(), is(2)); assertThat(fewEntries.get("key0"), is("value0")); assertThat(fewEntries.get("key2"), is("value2")); }
@Test public void testGetAll_cache_loader_throws_exception() throws Exception { CacheConfigurationBuilder cacheConfigurationBuilder = CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class, String.class, heap(100)); CacheLoaderWriterProvider cacheLoaderWriterProvider = mock(CacheLoaderWriterProvider.class); CacheLoaderWriter cacheLoaderWriter = mock(CacheLoaderWriter.class); when(cacheLoaderWriter.load(ArgumentMatchers.any())).thenThrow(new RuntimeException("We should not have called .load() but .loadAll()")); when(cacheLoaderWriter.loadAll(ArgumentMatchers.any(Iterable.class))).thenThrow(new Exception("Simulating an exception from the cache loader")); when(cacheLoaderWriterProvider.createCacheLoaderWriter(anyString(), ArgumentMatchers.any(CacheConfiguration.class))).thenReturn(cacheLoaderWriter); CacheManagerBuilder<CacheManager> managerBuilder = CacheManagerBuilder.newCacheManagerBuilder().using(cacheLoaderWriterProvider); CacheConfiguration<String, String> cacheConfiguration = cacheConfigurationBuilder.withLoaderWriter(cacheLoaderWriter).build(); CacheManager cacheManager = managerBuilder.withCache("myCache", cacheConfiguration).build(true); Cache<String, String> myCache = cacheManager.getCache("myCache", String.class, String.class); Set<String> fewKeysSet = new HashSet<String>() { { add("key0"); add("key2"); } }; // the call to getAll try { myCache.getAll(fewKeysSet); fail(); } catch (BulkCacheLoadingException bcwe) { // since onHeapStore.bulkComputeIfAbsent sends batches of 1 element, assertThat(bcwe.getFailures().size(), is(2)); assertThat(bcwe.getSuccesses().size(), is(0)); } }
@Test public void testGetAll_store_throws_cache_exception() throws Exception { CacheConfigurationBuilder cacheConfigurationBuilder = CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class, String.class, heap(100)); CacheConfiguration<String, String> cacheConfiguration = cacheConfigurationBuilder.build(); CacheLoaderWriterProvider cacheLoaderWriterProvider = mock(CacheLoaderWriterProvider.class); CacheLoaderWriter cacheLoaderWriter = mock(CacheLoaderWriter.class); when(cacheLoaderWriter.load(ArgumentMatchers.any())).thenThrow(new RuntimeException("We should not have called .load() but .loadAll()")); when(cacheLoaderWriterProvider.createCacheLoaderWriter(anyString(), ArgumentMatchers.any(CacheConfiguration.class))).thenReturn(cacheLoaderWriter); CacheManagerBuilder<CacheManager> managerBuilder = CacheManagerBuilder.newCacheManagerBuilder().using(cacheLoaderWriterProvider).using(new CustomStoreProvider()); CacheManager cacheManager = managerBuilder.withCache("myCache", cacheConfiguration).build(true); when(cacheLoaderWriter.loadAll(argThat(hasItems("key0", "key2")))).thenReturn( new HashMap(){{put("key0","value0"); put("key2","value2");}}); Cache<String, String> myCache = cacheManager.getCache("myCache", String.class, String.class); Set<String> fewKeysSet = new HashSet<String>() { { add("key0"); add("key2"); } }; // the call to getAll Map<String, String> fewEntries = myCache.getAll(fewKeysSet); assertThat(fewEntries.size(), is(2)); assertThat(fewEntries.get("key0"), is("value0")); assertThat(fewEntries.get("key2"), is("value2")); }
@Override public Map<K, V> loadAll(Iterable<? extends K> keys) throws BulkCacheLoadingException, Exception { return delegate.loadAll(keys); }
@Override public Map<K, V> loadAllAlways(Iterable<? extends K> keys) throws BulkCacheLoadingException, Exception { return delegate.loadAll(keys); }
/** * Get all entries for the provided keys. Entries not found by the loader-writer are expected to be an entry * with the key and a null value. * * @param keys the keys being retrieved * @param e the triggered failure * @return a map of key-value pairs as loaded by the loader-writer */ @SuppressWarnings("unchecked") @Override public Map<K, V> getAllFailure(Iterable<? extends K> keys, StoreAccessException e) { try { return loaderWriter.loadAll((Iterable) keys); // FIXME: bad typing that we should fix } catch(BulkCacheLoadingException e1) { throw e1; } catch (Exception e1) { throw ExceptionFactory.newCacheLoadingException(e1, e); } finally { cleanup(keys, e); } }
Map<? super K, ? extends V> loaded; try { loaded = cacheLoaderWriter.loadAll(keys1); } catch(BulkCacheLoadingException bcle) { loaded = Collections.emptyMap();