How to use

VCacheFactory

in

com.atlassian.vcache

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);