private StableReadExternalCache<String> getCache(String cacheName) { return cacheFactory.getStableReadExternalCache( cacheName, serializableMarshaller(String.class), new ExternalCacheSettingsBuilder().build() ); }
/** * Build {@link DirectExternalCache} and set up mockito expectations for appropriate calls of {@link VCacheFactory} * * @param mockVcacheFactory mockito proxied or mocked {@link VCacheFactory} * @param name name of the cache * @param clazz class of cached objects * @param settings cache settings * @param <T> type of cached objects * @return {@link DirectExternalCache} proxied by mockito. */ public static <T extends Serializable> DirectExternalCache<T> getExternalCache(VCacheFactory mockVcacheFactory, String name, Class<T> clazz, ExternalCacheSettings settings) { final DirectExternalCache<T> desiredCache = spy(mockVcacheFactory.getDirectExternalCache(name, JavaSerializationMarshalling.pair(clazz), settings)); doReturn(desiredCache).when(mockVcacheFactory).getDirectExternalCache(eq(name), any(MarshallingPair.class), any(ExternalCacheSettings.class)); return desiredCache; }
/** * Build {@link JvmCache} and set up mockito expectations for appropriate calls of {@link VCacheFactory} * * @param mockVcacheFactory mockito proxied or mocked {@link VCacheFactory} * @param cacheName name of the cache * @param settings cache settings * @param <K> type of cache keys * @param <V> type of cached objects * @return {@link JvmCache} proxied by mockito. */ public static <K, V> JvmCache<K, V> getJvmCache(VCacheFactory mockVcacheFactory, String cacheName, JvmCacheSettings settings) { final JvmCache<K, V> desiredCache = spy(mockVcacheFactory.getJvmCache(cacheName, settings)); doReturn(desiredCache).when(mockVcacheFactory).getJvmCache(eq(cacheName), any(JvmCacheSettings.class)); return desiredCache; }
protected void invalidateCache() { vCacheRequestFactory.getRequestCache(DESCRIPTORS_REQUEST_CACHE_KEY).removeAll(); vCacheRequestFactory.getRequestCache(REQUEST_CACHE_KEY).removeAll(); vCacheRequestFactory.getRequestCache(REMNANTS_REQUEST_CACHE_KEY).removeAll(); vCacheRequestFactory.getRequestCache(SHALLOW_BEAN_REQUEST_CACHE_KEY).removeAll(); }
@Test public void duplicate_names_different_policys() { final DirectExternalCache<String> directCache = vCacheFactory().getDirectExternalCache( "duplicate", StringMarshalling.pair(), new ExternalCacheSettingsBuilder().build()); thrown.expect(ExternalCacheException.class); thrown.expectMessage("Failed due to CREATION_FAILURE"); final StableReadExternalCache<String> stableCache = vCacheFactory().getStableReadExternalCache( "duplicate", StringMarshalling.pair(), new ExternalCacheSettingsBuilder().build()); }
/** * Build {@link TransactionalExternalCache} and set up mockito expectations for appropriate calls of {@link VCacheFactory} * * @param mockVcacheFactory mockito proxied or mocked {@link VCacheFactory} * @param name name of the cache * @param clazz class of cached objects * @param settings cache settings * @param <T> type of cached objects * @return {@link TransactionalExternalCache} proxied by mockito. */ public static <T extends Serializable> TransactionalExternalCache<T> getTransactionalCache(VCacheFactory mockVcacheFactory, String name, Class<T> clazz, ExternalCacheSettings settings) { final TransactionalExternalCache<T> desiredCache = spy(mockVcacheFactory.getTransactionalExternalCache(name, JavaSerializationMarshalling.pair(clazz), settings)); doReturn(desiredCache).when(mockVcacheFactory).getTransactionalExternalCache(eq(name), any(MarshallingPair.class), any(ExternalCacheSettings.class)); return desiredCache; }
protected void invalidateCache(String addonKey) { vCacheRequestFactory.getRequestCache(DESCRIPTORS_REQUEST_CACHE_KEY).remove(addonKey); vCacheRequestFactory.getRequestCache(REQUEST_CACHE_KEY).remove(addonKey); vCacheRequestFactory.getRequestCache(REMNANTS_REQUEST_CACHE_KEY).remove(addonKey); vCacheRequestFactory.getRequestCache(SHALLOW_BEAN_REQUEST_CACHE_KEY).remove(addonKey); }
@Test public void transactionalExternalCache_normal_marshalling() { final ExternalCacheSettings settings = new ExternalCacheSettingsBuilder() .defaultTtl(Duration.ofSeconds(60)) .entryGrowthRateHint(ChangeRate.LOW_CHANGE) .dataChangeRateHint(ChangeRate.LOW_CHANGE) .entryCountHint(100) .build(); final TransactionalExternalCache<String> cache = vCacheFactory().getTransactionalExternalCache( "my-txn-cache", StringMarshalling.pair(), settings); assertThat(cache, notNullValue()); assertThat(cache.getName(), is("my-txn-cache")); assertThat(invocationsOfBegunTxns, is(0)); cache.removeAll(); assertThat(invocationsOfBegunTxns, is(1)); cache.put("three", "drei", PUT_ALWAYS); final CompletionStage<Optional<String>> get1 = cache.get("three"); assertThat(get1, successfulWith(is(Optional.of("drei")))); vCacheLifecycleManager().transactionSync(currentRequestContext()); assertThat(invocationsOfBegunTxns, is(1)); forceNewRequestContext(); final CompletionStage<Optional<String>> get2 = cache.get("three"); assertThat(invocationsOfBegunTxns, is(2)); unsafeJoin(get2.toCompletableFuture()).get(); assertThat(get2, successfulWith(is(Optional.of("drei")))); assertThat(invocationsOfBegunTxns, is(2)); }
@SuppressWarnings("unchecked") private StableReadExternalCache<ImmutableMap<String, ImmutableList<ImmutableMap<String, PageProperty>>>> createCache(VCacheFactory cacheFactory) { return cacheFactory.getStableReadExternalCache( CACHE_NAME, (Marshaller) serializableMarshaller(ImmutableMap.class), new ExternalCacheSettingsBuilder().build() ); }
@Autowired public ConnectDynamicModuleProvider( final VertigoState vertigoState, @ComponentImport final DynamicModuleProviderRegistrar dynamicModuleProviderRegistrar, final ConnectPluginModuleDeserializerRegistry connectPluginModuleDeserializerRegistry, final TenantPluginModulesManager tenantPluginModulesManager, final PluginRetrievalService pluginRetrievalService, final VCacheFactory vCacheFactory, final EventPublisher eventPublisher) { this.vertigoState = vertigoState; this.dynamicModuleProviderRegistrar = dynamicModuleProviderRegistrar; this.connectPluginModuleDeserializerRegistry = connectPluginModuleDeserializerRegistry; this.tenantPluginModulesManager = tenantPluginModulesManager; this.pluginRetrievalService = pluginRetrievalService; this.eventPublisher = eventPublisher; requestPluginModulesByIdentifierReference = vCacheFactory.getRequestCache("com.atlassian.connect.module-provider.plugin-modules-by-identifier." + TenantPluginModuleProtos.PluginModuleCollection.class.hashCode()); requestModuleDescriptorsForDeserializerReference = vCacheFactory.getRequestCache("com.atlassian.connect.module-provider.module-descriptors-for-deserializer"); requestModuleVersionTracker = new ImmutableWorkContextReference<>(() -> new AtomicInteger(-1)); }
@Test public void transactionalExternalCache_normal_marshaller() { final ExternalCacheSettings settings = new ExternalCacheSettingsBuilder() .defaultTtl(Duration.ofSeconds(60)) .entryGrowthRateHint(ChangeRate.LOW_CHANGE) .dataChangeRateHint(ChangeRate.LOW_CHANGE) .entryCountHint(100) .build(); @SuppressWarnings("deprecation") final TransactionalExternalCache<String> cache = vCacheFactory().getTransactionalExternalCache( "my-txn-cache", MarshallerFactory.stringMarshaller(), settings); assertThat(cache, notNullValue()); assertThat(cache.getName(), is("my-txn-cache")); assertThat(invocationsOfBegunTxns, is(0)); cache.removeAll(); assertThat(invocationsOfBegunTxns, is(1)); cache.put("three", "drei", PUT_ALWAYS); final CompletionStage<Optional<String>> get1 = cache.get("three"); assertThat(get1, successfulWith(is(Optional.of("drei")))); vCacheLifecycleManager().transactionSync(currentRequestContext()); assertThat(invocationsOfBegunTxns, is(1)); forceNewRequestContext(); final CompletionStage<Optional<String>> get2 = cache.get("three"); assertThat(invocationsOfBegunTxns, is(2)); unsafeJoin(get2.toCompletableFuture()).get(); assertThat(get2, successfulWith(is(Optional.of("drei")))); assertThat(invocationsOfBegunTxns, is(2)); }
@Test public void directexternalcache_duplicate_obtain() { final DirectExternalCache<String> firstTime = vCacheFactory().getDirectExternalCache( "duplicate", dodgyPair("first"), new ExternalCacheSettingsBuilder().build()); final CompletionStage<Boolean> put1 = firstTime.put("key", "ignored", PUT_ALWAYS); assertThat(VCacheUtils.unsafeJoin(put1), is(true)); final CompletionStage<Optional<String>> get1 = firstTime.get("key"); assertThat(VCacheUtils.unsafeJoin(get1), is(Optional.of("first"))); final DirectExternalCache<String> secondTime = vCacheFactory().getDirectExternalCache( "duplicate", dodgyPair("second"), new ExternalCacheSettingsBuilder().build()); final CompletionStage<Optional<String>> get2 = secondTime.get("key"); assertThat(VCacheUtils.unsafeJoin(get2), is(Optional.of("second"))); }
.build(); final JvmCache<String, Long> cache = vCacheFactory().getJvmCache("my-jvm-cache", settings);
public TwitterRenderer(I18NBeanFactory i18NBeanFactory, LocaleManager localeManager, VCacheFactory cacheFactory, PageBuilderService pageBuilderService, VelocityRenderService velocityRenderService, HttpRetrievalService httpRetrievalService) { this.i18NBeanFactory = i18NBeanFactory; this.localeManager = localeManager; this.pageBuilderService = pageBuilderService; this.velocityRenderService = velocityRenderService; this.httpRetrievalService = httpRetrievalService; this.cacheRef = Lazy.supplier(() -> cacheFactory.getStableReadExternalCache( CACHE_NAME, serializableMarshaller(TweetRetrievalResult.class), new ExternalCacheSettingsBuilder().build() )); }
@Override public Optional<byte[]> getStoredData() { final Lock dataLock = requestLock.get(); // This lock ensures that the supplier for the stored data only gets called once. Ensuring that we only access the db once. dataLock.lock(); try { return vCacheFactory.<String, Optional<byte[]>>getRequestCache(STORED_REQUEST_CACHE_KEY).get(STORED_REQUEST_CACHE_DATA, storedDataRetriever); } finally { dataLock.unlock(); } }
@Test public void txnexternalcache_duplicate_obtain() { final TransactionalExternalCache<String> firstTime = vCacheFactory().getTransactionalExternalCache( "duplicate", dodgyPair("first"), new ExternalCacheSettingsBuilder().build()); firstTime.put("key", "ignored", PUT_ALWAYS); vCacheLifecycleManager().transactionSync(currentRequestContext()); forceNewRequestContext(); final CompletionStage<Optional<String>> get1 = firstTime.get("key"); assertThat(VCacheUtils.unsafeJoin(get1), is(Optional.of("first"))); final TransactionalExternalCache<String> secondTime = vCacheFactory().getTransactionalExternalCache( "duplicate", dodgyPair("second"), new ExternalCacheSettingsBuilder().build()); forceNewRequestContext(); final CompletionStage<Optional<String>> get2 = secondTime.get("key"); assertThat(VCacheUtils.unsafeJoin(get2), is(Optional.of("second"))); }
@Test public void directExternalCache_normal_marshalling() { final ExternalCacheSettings settings = new ExternalCacheSettingsBuilder() .defaultTtl(Duration.ofSeconds(60)) .entryGrowthRateHint(ChangeRate.LOW_CHANGE) .dataChangeRateHint(ChangeRate.LOW_CHANGE) .entryCountHint(100) .build(); final DirectExternalCache<String> cache = vCacheFactory().getDirectExternalCache( "my-direct-cache", StringMarshalling.pair(), settings); assertThat(cache, notNullValue()); assertThat(cache.getName(), is("my-direct-cache")); final CompletionStage<Void> rmall = cache.removeAll(); assertThat(rmall, successful()); final CompletionStage<Boolean> put1 = cache.put("one", "eine", PUT_ALWAYS); assertThat(put1, successfulWith(is(true))); final CompletionStage<Optional<String>> get1 = cache.get("one"); assertThat(get1, successfulWith(is(Optional.of("eine")))); assertThat(vCacheManagement().allJvmCacheDetails().size(), is(0)); assertThat(vCacheManagement().allRequestCacheDetails().size(), is(0)); final Map<String, ExternalCacheDetails> allCacheDetails = vCacheManagement().allExternalCacheDetails(); assertThat(allCacheDetails, notNullValue()); assertThat(allCacheDetails.keySet(), containsInAnyOrder("my-direct-cache")); final ExternalCacheDetails cacheDetails = allCacheDetails.get("my-direct-cache"); assertThat(cacheDetails.getName(), is("my-direct-cache")); assertThat(cacheDetails.getSettings().getDefaultTtl(), is(Optional.of(MAX_TTL))); assertThat(cacheDetails.getSettings().getEntryCountHint(), is(Optional.of(MAX_ENTRIES))); assertThat(invocationsOfBegunTxns, is(0)); }
@Test public void stablereadexternalcache_duplicate_obtain() { final StableReadExternalCache<String> firstTime = vCacheFactory().getStableReadExternalCache( "duplicate", dodgyPair("first"), new ExternalCacheSettingsBuilder().build()); final CompletionStage<Boolean> put1 = firstTime.put("key", "ignored", PUT_ALWAYS); assertThat(VCacheUtils.unsafeJoin(put1), is(true)); forceNewRequestContext(); final CompletionStage<Optional<String>> get1 = firstTime.get("key"); assertThat(VCacheUtils.unsafeJoin(get1), is(Optional.of("first"))); final StableReadExternalCache<String> secondTime = vCacheFactory().getStableReadExternalCache( "duplicate", dodgyPair("second"), new ExternalCacheSettingsBuilder().build()); forceNewRequestContext(); final CompletionStage<Optional<String>> get2 = secondTime.get("key"); assertThat(VCacheUtils.unsafeJoin(get2), is(Optional.of("second"))); }
@Override public Optional<String> getDescriptor(@Nonnull final String addonKey) { return vCacheRequestFactory.<String, Optional<String>>getRequestCache(DESCRIPTORS_REQUEST_CACHE_KEY).get(addonKey, () -> databaseConnectAddonDescriptorsPersister.getDescriptor(addonKey)); }
.build(); final TransactionalExternalCache<String> cache1 = vCacheFactory().getTransactionalExternalCache( "sync_sync_sync-1", StringMarshalling.pair(), settings); assertThat(invocationsOfBegunTxns, is(0)); assertThat(invocationsOfBegunTxns, is(1)); final TransactionalExternalCache<String> cache2 = vCacheFactory().getTransactionalExternalCache( "sync_sync_sync-2", StringMarshalling.pair(), settings); assertThat(invocationsOfBegunTxns, is(2)); final TransactionalExternalCache<String> cache3 = vCacheFactory().getTransactionalExternalCache( "sync_sync_sync-3", StringMarshalling.pair(), settings);