QuicClientSessionCache Class — netty Architecture

Source Code

codec-classes-quic/src/main/java/io/netty/handler/codec/quic/QuicClientSessionCache.java lines 27–246

final class QuicClientSessionCache {

    private static final int DEFAULT_CACHE_SIZE;
    static {
        // Respect the same system property as the JDK implementation to make it easy to switch between implementations.
        int cacheSize = SystemPropertyUtil.getInt("javax.net.ssl.sessionCacheSize", 20480);
        if (cacheSize >= 0) {
            DEFAULT_CACHE_SIZE = cacheSize;
        } else {
            DEFAULT_CACHE_SIZE = 20480;
        }
    }

    private final AtomicInteger maximumCacheSize = new AtomicInteger(DEFAULT_CACHE_SIZE);

    // Let's use the same default value as OpenSSL does.
    // See https://www.openssl.org/docs/man1.1.1/man3/SSL_get_default_timeout.html
    private final AtomicInteger sessionTimeout = new AtomicInteger(300);
    private int sessionCounter;

    private final Map<HostPort, SessionHolder> sessions =
            new LinkedHashMap<HostPort, SessionHolder>() {

                private static final long serialVersionUID = -7773696788135734448L;

                @Override
                protected boolean removeEldestEntry(Map.Entry<HostPort, SessionHolder> eldest) {
                    int maxSize = maximumCacheSize.get();
                    return maxSize >= 0 && size() > maxSize;
                }
            };

    void saveSession(@Nullable String host, int port, long creationTime, long timeout, byte[] session,
                     boolean isSingleUse) {
        HostPort hostPort = keyFor(host, port);
        if (hostPort != null) {
            synchronized (sessions) {
                // Mimic what OpenSSL is doing and expunge every 255 new sessions
                // See https://www.openssl.org/docs/man1.0.2/man3/SSL_CTX_flush_sessions.html
                if (++sessionCounter == 255) {
                    sessionCounter = 0;
                    expungeInvalidSessions();
                }

                sessions.put(hostPort, new SessionHolder(creationTime, timeout, session, isSingleUse));
            }
        }
    }

    // Only used for testing.
    boolean hasSession(@Nullable String host, int port) {
        HostPort hostPort = keyFor(host, port);
        if (hostPort != null) {
            synchronized (sessions) {
                return sessions.containsKey(hostPort);
            }
        }
        return false;
    }

    byte @Nullable [] getSession(@Nullable String host, int port) {
        HostPort hostPort = keyFor(host, port);
        if (hostPort != null) {
            SessionHolder sessionHolder;
            synchronized (sessions) {
                sessionHolder = sessions.get(hostPort);
                if (sessionHolder == null) {
                    return null;
                }
                if (sessionHolder.isSingleUse()) {
                    // Remove session as it should only be re-used once.
                    sessions.remove(hostPort);
                }
            }
            if (sessionHolder.isValid()) {
                return sessionHolder.sessionBytes();
            }
        }
        return null;
    }