RmiRequestDispatcher.java

/*
 * Copyright (C) 2012-2025 RRiBbit.org
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * https://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.rribbit.dispatching;

import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.rmi.server.RMIClientSocketFactory;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;

import javax.rmi.ssl.SslRMIClientSocketFactory;

import org.rribbit.Request;
import org.rribbit.Response;
import org.rribbit.processing.RmiRequestProcessor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * This {@link RequestDispatcher} dispatches a {@link Request} to an {@link RmiRequestProcessor} via RMI. It offers automatic loadbalancing and failover.
 * <p />
 * Note that the RMI connection is NOT maintained between requests, meaning that a new connection is set up each time a request is made to this {@link RmiRequestDispatcher}.
 * This also means that, if you choose to use SSL, an SSL handshake is done on each request.
 *
 * @author G.J. Schouten
 *
 */
public class RmiRequestDispatcher implements RequestDispatcher {

	private static final Logger log = LoggerFactory.getLogger(RmiRequestDispatcher.class);

	protected int retryAttempts = 10;
	protected int portnumber;
	protected String[] hosts;
	protected String truststoreLocation;

	/**
	 * Connects to {@link RmiRequestProcessor}s that run on the specified port and on the specified hosts. If multiple hosts are specified, one is randomly chosen at runtime,
	 * creating automatic load-balancing. If a connection to a host fails, another one is chosen. The default number of retries is 10 and can be set with the corresponding setter.
	 * <p />
	 * Use this constructor if you do NOT want to use SSL.
	 *
	 * @param portnumber			The portnumber to use
	 * @param hosts					The hosts to connect to, you can specify one host multiple times, to give it a proportionally larger chance of being chosen
	 */
	public RmiRequestDispatcher(int portnumber, String... hosts) {

		this.portnumber = portnumber;
		this.hosts = hosts;
	}

	/**
	 * Connects to {@link RmiRequestProcessor}s that run on the specified port and on the specified hosts. If multiple hosts are specified, one is randomly chosen at runtime,
	 * creating automatic load-balancing. If a connection to a host fails, another one is chosen. The default number of retries is 10 and can be set with the corresponding setters.
	 * <p />
	 * Use this constructor if you DO want to use SSL. The "javax.net.ssl.trustStore" system property will be set.
	 *
	 * @param truststoreLocation	The filepath that contains the SSL truststore, without file://
	 * @param portnumber			The portnumber to use
	 * @param hosts					The hosts to connect to, you can specify one host multiple times, to give it a proportionally larger chance of being chosen
	 */
	public RmiRequestDispatcher(String truststoreLocation, int portnumber, String... hosts) {

		this.truststoreLocation = truststoreLocation;
		this.portnumber = portnumber;
		this.hosts = hosts;

		System.setProperty("javax.net.ssl.trustStore", truststoreLocation);
	}

	@Override
	public <T> Response<T> dispatchRequest(Request request) {

		List<String> hostsAsList = new ArrayList<>(Arrays.asList(hosts));

		log.info("Connecting to an RmiRequestProcessorImpl");
		for(int i=0; i<retryAttempts; i++) {
			log.info("Attempt: {} (Max Attempts: {})", i+1, retryAttempts);

			//If all the available hosts have been tried, then start over
			if(hostsAsList.isEmpty()) {
				log.info("All hosts have been tried. Re-loading...");
				hostsAsList = new ArrayList<>(Arrays.asList(hosts));
			}

			//Pick a host from the available host and remove it from the list
			int number = new Random().nextInt(hostsAsList.size());
			String host = hostsAsList.remove(number);

			//Connect to the host and dispatch the Request
			try {
				log.info("Connecting to server: '{}:{}'", host, portnumber);
				Registry registry;
				if(truststoreLocation == null) { //No SSL
					registry = LocateRegistry.getRegistry(host, portnumber);
				} else { //SSL
					RMIClientSocketFactory csf = new SslRMIClientSocketFactory();
					registry = LocateRegistry.getRegistry(host, portnumber, csf);
				}

				RmiRequestProcessor rmiRequestProcessor = (RmiRequestProcessor) (registry.lookup(RmiRequestProcessor.REGISTRY_KEY));
				Response<T> response = rmiRequestProcessor.processRequestViaRMI(request);
				log.info("Returning Response");
				return response;
			} catch(Exception e) {
				log.error("Connection failed, trying again...", e);
			}
		}
		log.error("No connection to an RmiRequestProcessorImpl could be made");
		throw new RuntimeException("No connection to an RmiRequestProcessorImpl could be made");
	}

	/**
	 * Gets the number of times this {@link RmiRequestDispatcher} retries when it cannot connect to the {@link RmiRequestProcessor}. The default is 10.
	 */
	public int getRetryAttempts() {
		return retryAttempts;
	}

	/**
	 * Sets the number of times this {@link RmiRequestDispatcher} retries when it cannot connect to the {@link RmiRequestProcessor}. The default is 10.
	 *
	 * @param retryAttempts
	 */
	public void setRetryAttempts(int retryAttempts) {
		this.retryAttempts = retryAttempts;
	}
}