RevocationServer Class — netty Architecture

Source Code

pkitesting/src/main/java/io/netty/pkitesting/RevocationServer.java lines 46–202

public final class RevocationServer {
    private static volatile RevocationServer instance;

    private final HttpServer crlServer;
    private final String crlBaseAddress;
    private final AtomicInteger issuerCounter;
    private final ConcurrentMap<X509Certificate, CrlInfo> issuers;
    private final ConcurrentMap<String, CrlInfo> paths;

    /**
     * Get the shared revocation server instance.
     * This will start the server, if it isn't already running, and bind it to a random port on the loopback address.
     * @return The revocation server instance.
     * @throws Exception If the server failed to start.
     */
    public static RevocationServer getInstance() throws Exception {
        if (instance != null) {
            return instance;
        }
        synchronized (RevocationServer.class) {
            RevocationServer server = instance;
            if (server == null) {
                server = new RevocationServer();
                server.start();
                instance = server;
            }
            return server;
        }
    }

    private RevocationServer() throws Exception {
        // Use the JDK built-in HttpServer to avoid any circular dependencies with Netty itself.
        crlServer = HttpServer.create(new InetSocketAddress(InetAddress.getLoopbackAddress(), 0), 0);
        crlBaseAddress = "http://localhost:" + crlServer.getAddress().getPort();
        issuerCounter = new AtomicInteger();
        issuers = new ConcurrentHashMap<>();
        paths = new ConcurrentHashMap<>();
        crlServer.createContext("/", exchange -> {
            if ("GET".equals(exchange.getRequestMethod())) {
                String path = exchange.getRequestURI().getPath();
                CrlInfo info = paths.get(path);
                if (info == null) {
                    exchange.sendResponseHeaders(404, 0);
                    exchange.close();
                    return;
                }
                byte[] crl = generateCrl(info);
                exchange.getResponseHeaders().put("Content-Type", Collections.singletonList("application/pkix-crl"));
                exchange.sendResponseHeaders(200, crl.length);
                try (OutputStream out = exchange.getResponseBody()) {
                    out.write(crl);
                    out.flush();
                }
            } else {
                exchange.sendResponseHeaders(405, 0);
            }
            exchange.close();
        });
    }

    private void start() {
        if (Thread.currentThread().isDaemon()) {
            crlServer.start();
        } else {
            // It's important the CRL server creates a daemon thread,
            // because it's a singleton and won't be stopped except by terminating the JVM.
            // Threads in the ForkJoin common pool are always daemon, and JUnit 5 initializes
            // it anyway, so we can let it call start() for us.
            ForkJoinPool.commonPool().execute(crlServer::start);
        }
    }

    /**
     * Register an issuer with the revocation server.
     * This must be done before CRLs can be served for that issuer, and before any of its certificates can be revoked.
     * @param issuer The issuer to register.
     */
    public void register(X509Bundle issuer) {
        register(issuer, null);
    }