io.quarkus.smallrye.faulttolerance.runtime.QuarkusFaultToleranceOperationProvider Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of quarkus-smallrye-fault-tolerance Show documentation

Build fault-tolerant network services

There is a newer version: 3.17.0.CR1

Show newest version

package io.quarkus.smallrye.faulttolerance.runtime;

import java.lang.reflect.Method;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;

import jakarta.annotation.Priority;
import jakarta.enterprise.inject.Alternative;
import jakarta.inject.Singleton;

import org.jboss.logging.Logger;

import io.smallrye.faulttolerance.FaultToleranceOperationProvider;
import io.smallrye.faulttolerance.config.FaultToleranceMethods;
import io.smallrye.faulttolerance.config.FaultToleranceOperation;

@Singleton
@Alternative
@Priority(1)
public class QuarkusFaultToleranceOperationProvider implements FaultToleranceOperationProvider {
    private static final Logger LOG = Logger.getLogger(QuarkusFaultToleranceOperationProvider.class);

    private final Map operationCache = new ConcurrentHashMap<>();
    private final Function cacheFunction = new Function() {
        @Override
        public FaultToleranceOperation apply(CacheKey key) {
            return createAtRuntime(key);
        }
    };

    /**
     * Called by SmallRyeFaultToleranceRecorder to init the operation cache.
     */
    void init(Map operationCache) {
        this.operationCache.putAll(operationCache);
    }

    @Override
    public FaultToleranceOperation get(Class beanClass, Method method) {
        CacheKey key = new CacheKey(beanClass, method);
        FaultToleranceOperation existing = operationCache.get(key);
        return existing != null ? existing : operationCache.computeIfAbsent(key, cacheFunction);
    }

    private FaultToleranceOperation createAtRuntime(CacheKey key) {
        LOG.debugf("FaultToleranceOperation not found in the cache for %s creating it at runtime", key);
        return FaultToleranceOperation.create(FaultToleranceMethods.create(key.beanClass, key.method));
    }

    public Map getOperationCache() {
        return operationCache;
    }

    static class CacheKey {
        private Class beanClass;
        private Method method;
        private int hashCode;

        public CacheKey(Class beanClass, Method method) {
            this.beanClass = beanClass;
            this.method = method;
            this.hashCode = Objects.hash(beanClass, method);
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            CacheKey cacheKey = (CacheKey) o;
            return Objects.equals(beanClass, cacheKey.beanClass) &&
                    Objects.equals(method, cacheKey.method);
        }

        @Override
        public int hashCode() {
            return this.hashCode;
        }
    }
}