matlabcontrol.internal.MatlabRMIClassLoaderSpi Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of matlabcontrol Show documentation
MatConsoleCtl - control MATLAB from Java
There is a newer version: 4.6.1
/*
 * Copyright (c) 2013, Joshua Kaplan
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
 * following conditions are met:
 *  - Redistributions of source code must retain the above copyright notice, this list of conditions and the following
 *    disclaimer.
 *  - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the
 *    following disclaimer in the documentation and/or other materials provided with the distribution.
 *  - Neither the name of matlabcontrol nor the names of its contributors may be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
package matlabcontrol.internal;

import java.io.File;
import java.net.MalformedURLException;
import java.rmi.server.RMIClassLoader;
import java.rmi.server.RMIClassLoaderSpi;

/**
 * Internal Use Only
 * 


 * This class must be public so that it can be created via reflection by {@link RemoteClassLoader}. If it were package
 * private it would result in an {@link IllegalAccessError} because only classes in the same package as a package
 * private class may construct it (even via reflection). It has been placed in the {@code matlabcontrol.internal}
 * package to make it clear it is not intended for use by users of matlabcontrol.
 * 


 * A custom service provider for the RMI class loader. Allows for loading classes sent from the external JVM and
 * providing annotations so that the external JVM may load classes defined only in the MATLAB JVM. Loading classes from
 * the external JVM could be accomplished by setting {@code java.rmi.server.codebase} property in the external JVM but
 * that could interfere with other uses of RMI in the application. There is no way to always sending the correct
 * annotations without this custom rmi class loader spi. While the {@code java.rmi.server.codebase} property could be
 * set in the MATLAB JVM, the property is checked only at load time. This would mean that class definitions added
 * dynamically with {@code javaaddpath} could not be sent.
 * 
 * @since 4.0.0
 * 
 * @author Joshua Kaplan
 * 
 */
public class MatlabRMIClassLoaderSpi extends RMIClassLoaderSpi {
	/**
	 * Loading of classes is delegated to the default {@link RMIClassLoaderSpi}.
	 */
	private final RMIClassLoaderSpi _delegateLoaderSpi = RMIClassLoader.getDefaultProviderInstance();

	/**
	 * The codebase of the external virtual machine which has a proxy that can interact with this session of MATLAB.
	 * This is done instead of setting the {@code java.rmi.server.codebase} property so that matlabcontrol does not
	 * interfere with any other uses of RMI in the application.
	 */
	private static volatile String _remoteCodebase = null;

	/**
	 * Sets the codebase of the currently connected external JVM. This should be called only once per connection to an
	 * external JVM and should occur before users of the API can send objects over RMI.
	 * 
	 * @param remoteCodebase 
	 */
	public static void setCodebase(String remoteCodebase) {
		_remoteCodebase = remoteCodebase;
	}

	@Override
	public Class loadClass(String codebase, String name, ClassLoader defaultLoader) throws MalformedURLException, ClassNotFoundException {
		return _delegateLoaderSpi.loadClass(_remoteCodebase, name, defaultLoader);
	}

	@Override
	public Class loadProxyClass(String codebase, String[] interfaces, ClassLoader defaultLoader) throws MalformedURLException, ClassNotFoundException {
		return _delegateLoaderSpi.loadProxyClass(_remoteCodebase, interfaces, defaultLoader);
	}

	@Override
	public ClassLoader getClassLoader(String codebase) throws MalformedURLException {
		return _delegateLoaderSpi.getClassLoader(_remoteCodebase);
	}

	/**
	 * {@inheritDoc}
	 * 


	 * The returned annotation becomes the {@code codebase} argument in
	 * {@link #loadClass(java.lang.String, java.lang.String, java.lang.ClassLoader)} when the {@code RMIClassLoaderSpi}
	 * in the receiving JVM attempts to load {@code clazz}. This allows for classes defined in MATLAB but not in the
	 * receiving JVM to find and load the class definition.
	 * 
	 * @param clazz
	 * @return 
	 */
	@Override
	public String getClassAnnotation(Class clazz) {
		if (clazz == null) {
			throw new NullPointerException("class may not be null");
		}

		String annotation = null;

		//If the class has a code source, meaning it is not part of the Java Runtime Environment
		if (clazz.getProtectionDomain().getCodeSource() != null) {
			//This convoluted way of determining the code source location is necessary due to a bug in early versions of
			//Java 6 on Windows (such as what is used by MATLAB R2007b) which puts a space in the code source's URL.
			//A space in the URL will cause the receiver of this annotation to treat it as a path separator, which would
			//be very problematic and likely cause invalid protocol exceptions.
			try {
				File file = new File(clazz.getProtectionDomain().getCodeSource().getLocation().getPath());
				annotation = file.toURI().toURL().toString();
			} catch (MalformedURLException e) {}
		}

		return annotation;
	}
}