AbstractVCacheService

package com.atlassian.vcache.internal.core.service;

import com.atlassian.marshalling.api.MarshallingPair;
import com.atlassian.vcache.DirectExternalCache;
import com.atlassian.vcache.ExternalCache;
import com.atlassian.vcache.ExternalCacheException;
import com.atlassian.vcache.ExternalCacheSettings;
import com.atlassian.vcache.JvmCache;
import com.atlassian.vcache.JvmCacheSettings;
import com.atlassian.vcache.Marshaller;
import com.atlassian.vcache.RequestCache;
import com.atlassian.vcache.StableReadExternalCache;
import com.atlassian.vcache.TransactionalExternalCache;
import com.atlassian.vcache.VCacheFactory;
import com.atlassian.vcache.internal.BegunTransactionalActivityHandler;
import com.atlassian.vcache.internal.ExternalCacheDetails;
import com.atlassian.vcache.internal.JvmCacheDetails;
import com.atlassian.vcache.internal.RequestCacheDetails;
import com.atlassian.vcache.internal.RequestContext;
import com.atlassian.vcache.internal.RequestMetrics;
import com.atlassian.vcache.internal.VCacheCreationHandler;
import com.atlassian.vcache.internal.VCacheLifecycleManager;
import com.atlassian.vcache.internal.VCacheManagement;
import com.atlassian.vcache.internal.VCacheSettingsDefaultsProvider;
import com.atlassian.vcache.internal.core.DefaultExternalCacheDetails;
import com.atlassian.vcache.internal.core.DefaultJvmCacheDetails;
import com.atlassian.vcache.internal.core.DefaultRequestCacheDetails;
import com.atlassian.vcache.internal.core.DefaultTransactionControlManager;
import com.atlassian.vcache.internal.core.ExternalCacheKeyGenerator;
import com.atlassian.vcache.internal.core.TransactionControlManager;
import com.atlassian.vcache.internal.core.metrics.MetricsCollector;
import com.google.common.annotations.VisibleForTesting;
import org.slf4j.Logger;

import java.time.Duration;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Supplier;

import static com.atlassian.vcache.internal.NameValidator.requireValidCacheName;
import static java.util.Objects.requireNonNull;

/**
 * Base implementation of a service.
 *
 * @since 1.0.0
 */
public abstract class AbstractVCacheService implements VCacheFactory, VCacheManagement, VCacheLifecycleManager {
    // List of Marshaller class names that support Serializable values. This is a slightly
    // dodgy approach, but the rationale is to not be forced to make implementations
    // visible, or to make it an attribute of a Marshaller. The fact is, this is a temporary
    // hack for internal use only.
    private static final Set<String> SERIALIZABLE_MARSHALLER_CLASS_NAMES =
            Collections.unmodifiableSet(new HashSet<>(Arrays.asList(
                    "com.atlassian.vcache.marshallers.StringMarshaller",
                    "com.atlassian.vcache.marshallers.JavaSerializationMarshaller")));
    private static final Set<String> SERIALIZABLE_MARSHALLING_CLASS_NAMES =
            Collections.unmodifiableSet(new HashSet<>(Arrays.asList(
                    "com.atlassian.marshalling.jdk.JavaSerializationMarshalling",
                    "com.atlassian.marshalling.jdk.StringMarshalling")));

    protected final Supplier<RequestContext> workContextContextSupplier;
    protected final Supplier<RequestContext> threadLocalContextSupplier;
    protected final TransactionControlManager transactionControlManager;
    protected final MetricsCollector metricsCollector;

    protected final ExternalCacheKeyGenerator externalCacheKeyGenerator;
    protected final Duration lockTimeout;
    private final VCacheSettingsDefaultsProvider defaultsProvider;
    private final VCacheCreationHandler creationHandler;

    private final ConcurrentHashMap<String, JvmCache> jvmCacheInstancesMap = new ConcurrentHashMap<>();
    private final ConcurrentHashMap<String, JvmCacheDetails> jvmCacheDetailsMap = new ConcurrentHashMap<>();

    private final ConcurrentHashMap<String, RequestCache> requestCacheInstancesMap = new ConcurrentHashMap<>();
    private final ConcurrentHashMap<String, RequestCacheDetails> requestCacheDetailsMap = new ConcurrentHashMap<>();

    private final ConcurrentHashMap<String, ExternalCache> externalCacheInstancesMap = new ConcurrentHashMap<>();
    private final ConcurrentHashMap<String, ExternalCacheDetails> externalCacheDetailsMap = new ConcurrentHashMap<>();

    public AbstractVCacheService(Supplier<RequestContext> threadLocalContextSupplier,
                                 Supplier<RequestContext> workContextContextSupplier,
                                 VCacheSettingsDefaultsProvider defaultsProvider,
                                 VCacheCreationHandler creationHandler,
                                 MetricsCollector metricsCollector,
                                 ExternalCacheKeyGenerator externalCacheKeyGenerator,
                                 BegunTransactionalActivityHandler begunTransactionalActivityHandler,
                                 Duration lockTimeout) {
        this.threadLocalContextSupplier = requireNonNull(threadLocalContextSupplier);
        this.workContextContextSupplier = requireNonNull(workContextContextSupplier);
        this.defaultsProvider = requireNonNull(defaultsProvider);
        this.creationHandler = requireNonNull(creationHandler);
        this.metricsCollector = requireNonNull(metricsCollector);
        this.transactionControlManager = new DefaultTransactionControlManager(metricsCollector, begunTransactionalActivityHandler);
        this.externalCacheKeyGenerator = requireNonNull(externalCacheKeyGenerator);
        this.lockTimeout = requireNonNull(lockTimeout);
    }

    /**
     * Returns the logger for the implementation service.
     *
     * @return the logger for the implementation service.
     */
    protected abstract Logger log();

    /**
     * Creates a {@link JvmCache} with the supplied parameters.
     *
     * @param name     the name of the cache
     * @param settings the setting for the cache
     * @param <K>      the key type
     * @param <V>      the value type
     * @return a freshly minted {@link JvmCache}
     */
    protected abstract <K, V> JvmCache<K, V> createJvmCache(String name, JvmCacheSettings settings);

    /**
     * Creates a {@link TransactionalExternalCache} with the supplied parameters.
     *
     * @param name              the name of the cache
     * @param settings          the settings for the cache
     * @param valueMarshalling  the marshalling pair for values
     * @param valueSerializable whether the values are {@link java.io.Serializable}
     * @param <V>               the value type
     * @return a freshly minted {@link TransactionalExternalCache}
     */
    protected abstract <V> TransactionalExternalCache<V> createTransactionalExternalCache(
            String name, ExternalCacheSettings settings, MarshallingPair<V> valueMarshalling, boolean valueSerializable);

    /**
     * Creates a {@link StableReadExternalCache} with the supplied parameters.
     *
     * @param name              the name of the cache
     * @param settings          the settings for the cache
     * @param valueMarshalling  the marshalling pair for values
     * @param valueSerializable whether the values are {@link java.io.Serializable}
     * @param <V>               the value type
     * @return a freshly minted {@link StableReadExternalCache}
     */
    protected abstract <V> StableReadExternalCache<V> createStableReadExternalCache(
            String name, ExternalCacheSettings settings, MarshallingPair<V> valueMarshalling, boolean valueSerializable);

    /**
     * Creates a {@link DirectExternalCache} with the supplied parameters.
     *
     * @param name              the name of the cache
     * @param settings          the settings for the cache
     * @param valueMarshalling  the marshalling pair for values
     * @param valueSerializable whether the values are {@link java.io.Serializable}
     * @param <V>               the value type
     * @return a freshly minted {@link DirectExternalCache}
     */
    protected abstract <V> DirectExternalCache<V> createDirectExternalCache(
            String name, ExternalCacheSettings settings, MarshallingPair<V> valueMarshalling, boolean valueSerializable);

    @Override
    @SuppressWarnings("unchecked")
    public <K, V> JvmCache<K, V> getJvmCache(String name, JvmCacheSettings settings) {
        return jvmCacheInstancesMap.computeIfAbsent(requireValidCacheName(name), s -> {
            log().trace("Cache {}: creating the instance", name);
            final JvmCacheSettings candidateSettings = defaultsProvider.getJvmDefaults(name).override(settings);
            final JvmCacheSettings finalSettings =
                    creationHandler.jvmCacheCreation(new DefaultJvmCacheDetails(name, candidateSettings));
            jvmCacheDetailsMap.put(name, new DefaultJvmCacheDetails(name, finalSettings));

            return metricsCollector.wrap(createJvmCache(name, finalSettings));
        });
    }

    @Override
    @SuppressWarnings("unchecked")
    public <K, V> RequestCache<K, V> getRequestCache(String name) {
        return requestCacheInstancesMap.computeIfAbsent(requireValidCacheName(name), s -> {
            log().trace("Cache {}: creating the instance", name);
            creationHandler.requestCacheCreation(name);
            requestCacheDetailsMap.put(name, new DefaultRequestCacheDetails(name));
            return metricsCollector.wrap(new DefaultRequestCache(name, workContextContextSupplier, lockTimeout));
        });
    }

    @Override
    public <V> TransactionalExternalCache<V> getTransactionalExternalCache(String name, MarshallingPair<V> valueMarshalling, ExternalCacheSettings settings) {
        final MarshallingPair<V> wrappedMarshalling = metricsCollector.wrap(valueMarshalling, name);

        final TransactionalExternalCache<V> cache = obtainCache(
                name, ExternalCacheDetails.BufferPolicy.FULLY, settings, finalSettings ->
                        createTransactionalExternalCache(
                                name, finalSettings, wrappedMarshalling, isValueSerializable(valueMarshalling)));
        return metricsCollector.wrap(cache);
    }

    @Override
    public <V> TransactionalExternalCache<V> getTransactionalExternalCache(
            String name, @SuppressWarnings("deprecation") Marshaller<V> valueMarshaller, ExternalCacheSettings settings) {
        final MarshallingPair<V> marshallingPair =
                new MarshallingPair<>(valueMarshaller, valueMarshaller);
        final MarshallingPair<V> wrappedMarshalling = metricsCollector.wrap(marshallingPair, name);

        final TransactionalExternalCache<V> cache = obtainCache(
                name, ExternalCacheDetails.BufferPolicy.FULLY, settings, finalSettings ->
                        createTransactionalExternalCache(
                                name, finalSettings, wrappedMarshalling, isValueSerializable(valueMarshaller)));
        return metricsCollector.wrap(cache);
    }

    @Override
    public <V> StableReadExternalCache<V> getStableReadExternalCache(String name, MarshallingPair<V> valueMarshalling, ExternalCacheSettings settings) {
        final MarshallingPair<V> wrappedMarshalling = metricsCollector.wrap(valueMarshalling, name);
        final StableReadExternalCache<V> cache = obtainCache(
                name, ExternalCacheDetails.BufferPolicy.READ_ONLY, settings, finalSettings ->
                        createStableReadExternalCache(
                                name, finalSettings, wrappedMarshalling, isValueSerializable(valueMarshalling)));
        return metricsCollector.wrap(cache);
    }

    @Override
    public <V> StableReadExternalCache<V> getStableReadExternalCache(
            String name, @SuppressWarnings("deprecation") Marshaller<V> valueMarshaller, ExternalCacheSettings settings) {
        final MarshallingPair<V> marshallingPair =
                new MarshallingPair<>(valueMarshaller, valueMarshaller);
        final MarshallingPair<V> wrappedMarshalling = metricsCollector.wrap(marshallingPair, name);

        final StableReadExternalCache<V> cache = obtainCache(
                name, ExternalCacheDetails.BufferPolicy.READ_ONLY, settings, finalSettings ->
                        createStableReadExternalCache(
                                name, finalSettings, wrappedMarshalling, isValueSerializable(valueMarshaller)));
        return metricsCollector.wrap(cache);
    }

    @Override
    public <V> DirectExternalCache<V> getDirectExternalCache(String name, MarshallingPair<V> valueMarshalling, ExternalCacheSettings settings) {
        final MarshallingPair<V> wrappedMarshalling = metricsCollector.wrap(valueMarshalling, name);
        final DirectExternalCache<V> cache = obtainCache(
                name, ExternalCacheDetails.BufferPolicy.NEVER, settings, finalSettings ->
                        createDirectExternalCache(
                                name, finalSettings, wrappedMarshalling, isValueSerializable(valueMarshalling)));
        return metricsCollector.wrap(cache);
    }

    @Override
    public <V> DirectExternalCache<V> getDirectExternalCache(
            String name, @SuppressWarnings("deprecation") Marshaller<V> valueMarshaller, ExternalCacheSettings settings) {
        final MarshallingPair<V> marshallingPair =
                new MarshallingPair<>(valueMarshaller, valueMarshaller);
        final MarshallingPair<V> wrappedMarshalling = metricsCollector.wrap(marshallingPair, name);

        final DirectExternalCache<V> cache = obtainCache(
                name, ExternalCacheDetails.BufferPolicy.NEVER, settings, finalSettings ->
                        createDirectExternalCache(
                                name, finalSettings, wrappedMarshalling, isValueSerializable(valueMarshaller)));
        return metricsCollector.wrap(cache);
    }

    @Override
    public void transactionSync(RequestContext context) {
        transactionControlManager.syncAll(context);
    }

    @Override
    public Set<String> transactionDiscard(RequestContext context) {
        return transactionControlManager.discardAll(context);
    }

    @Override
    public RequestMetrics metrics(RequestContext context) {
        return metricsCollector.obtainRequestMetrics(context);
    }

    @Override
    public Map<String, JvmCacheDetails> allJvmCacheDetails() {
        final Map<String, JvmCacheDetails> result = new HashMap<>();
        result.putAll(jvmCacheDetailsMap);
        return result;
    }

    @Override
    public Map<String, RequestCacheDetails> allRequestCacheDetails() {
        final Map<String, RequestCacheDetails> result = new HashMap<>();
        result.putAll(requestCacheDetailsMap);
        return result;
    }

    @Override
    public Map<String, ExternalCacheDetails> allExternalCacheDetails() {
        final Map<String, ExternalCacheDetails> result = new HashMap<>();
        result.putAll(externalCacheDetailsMap);
        return result;
    }

    @VisibleForTesting
    static <V> boolean isValueSerializable(@SuppressWarnings("deprecation") Marshaller<V> valueMarshaller) {
        return SERIALIZABLE_MARSHALLER_CLASS_NAMES.contains(valueMarshaller.getClass().getName());
    }

    @VisibleForTesting
    static <V> boolean isValueSerializable(MarshallingPair<V> valueMarshalling) {
        return SERIALIZABLE_MARSHALLING_CLASS_NAMES.contains(valueMarshalling.getMarshaller().getClass().getName())
                && SERIALIZABLE_MARSHALLING_CLASS_NAMES.contains(valueMarshalling.getUnmarshaller().getClass().getName());
    }

    @SuppressWarnings("unchecked")
    private <C extends ExternalCache> C obtainCache(
            String name,
            ExternalCacheDetails.BufferPolicy policy,
            ExternalCacheSettings settings,
            Function<ExternalCacheSettings, C> factory) {
        final ExternalCache candidateCache = externalCacheInstancesMap.compute(
                requireValidCacheName(name),
                (key, existing) -> {
                    // Check if attempting to change the policy, a no no
                    if ((existing != null) && (externalCacheDetailsMap.get(name).getPolicy() != policy)) {
                        log().warn("Cache {}: unable to create cache with policy {}, as one already configured with policy {}",
                                name, ExternalCacheDetails.BufferPolicy.READ_ONLY, externalCacheDetailsMap.get(name).getPolicy());
                        throw new ExternalCacheException(ExternalCacheException.Reason.CREATION_FAILURE);
                    }

                    // Now always create a new cache wrapper, regardless of whether one existed before.
                    log().trace("Cache {}: creating the instance with policy {}", name, policy);
                    final ExternalCacheSettings candidateSettings =
                            defaultsProvider.getExternalDefaults(name).override(settings);
                    final ExternalCacheSettings finalSettings = creationHandler.externalCacheCreation(
                            new DefaultExternalCacheDetails(name, policy, candidateSettings));
                    externalCacheDetailsMap.put(
                            name, new DefaultExternalCacheDetails(name, policy, finalSettings));
                    return factory.apply(finalSettings);
                });

        return (C) candidateCache;
    }
}