org.biojava.nbio.structure.align.util.UserConfiguration Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of biojava-structure Show documentation
The protein structure modules of BioJava.
There is a newer version: 7.1.3
/*
 *                    PDB web development code
 *
 * This code may be freely distributed and modified under the
 * terms of the GNU Lesser General Public Licence.  This should
 * be distributed with the code.  If you do not have a copy,
 * see:
 *
 *      http://www.gnu.org/copyleft/lesser.html
 *
 * Copyright for this code is held jointly by the individual
 * authors.  These should be listed in @author doc comments.
 *
 *
 * Created on Jul 8, 2009
 * Created by ap3
 *
 */

package org.biojava.nbio.structure.align.util;

import org.biojava.nbio.structure.align.ce.StartupParameters;
import org.biojava.nbio.structure.io.LocalPDBDirectory.FetchBehavior;
import org.biojava.nbio.structure.io.LocalPDBDirectory.ObsoleteBehavior;
import org.biojava.nbio.core.util.PrettyXMLWriter;
import org.biojava.nbio.core.util.XMLWriter;
import org.biojava.nbio.structure.io.StructureFiletype;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;


/** A container to persist config to the file system
 *
 * @author Andreas Prlic
 *
 */
public class UserConfiguration
{

	private static final Logger logger = LoggerFactory.getLogger(UserConfiguration.class);

	public static final String PDB_FORMAT   = "PDB";
	public static final String MMCIF_FORMAT = "mmCif";
	public static final String MMTF_FORMAT  = "mmtf";
	public static final String BCIF_FORMAT  = "bcif";

	public static final String TMP_DIR = "java.io.tmpdir";

	public static final String PDB_DIR   = "PDB_DIR";
	public static final String PDB_CACHE_DIR = "PDB_CACHE_DIR";

	public static final String lineSplit = System.getProperty("file.separator");

	private String pdbFilePath;
	private String cacheFilePath;

	private FetchBehavior fetchBehavior;
	private ObsoleteBehavior obsoleteBehavior;

	private String fileFormat;

	private static AtomicBoolean warningShown = new AtomicBoolean(false);


	/**
	 * Default UserConfiguration:
	 * 
	 * split directory
	 * autofetch files
	 * default download location. This is the first specified of:
	 * 	{@value #PDB_DIR} system property (for instance, -D{@value #PDB_DIR}=/tmp)
	 *   {@value #PDB_DIR} environment variable
	 *   System temp directory (java.io.tmpdir property)
	 *   
	 *   if the provided path is not a directory then
	 *   the system's temp directory is used. A non-writable path is allowed,
	 *   only a warning will be logged.
	 * 
	 * default cache location. This is the first specified of:
	 * 	{@value #PDB_CACHE_DIR} system property (for instance, -D{@value #PDB_CACHE_DIR}=/tmp)
	 *   {@value #PDB_CACHE_DIR} environment variable
	 *   the value set for {@value #PDB_DIR}
	 *   
	 *   if the provided path is not a directory or is not writable then
	 *   the system's temp directory is used.
	 * 
	 * 
	 */
	public UserConfiguration(){
		fetchBehavior = FetchBehavior.DEFAULT;
		obsoleteBehavior = ObsoleteBehavior.DEFAULT;

		pdbFilePath = initPdbFilePath();
		// note that in initCacheFilePath, we set to the provided one (if readable) or to the same as pdbFilePath
		cacheFilePath = initCacheFilePath();

		fileFormat = BCIF_FORMAT;
	}

	private String initPdbFilePath() {

		String path = null;

		String propertyName = PDB_DIR;

		String userProvidedDir = System.getProperty(propertyName);

		if ( userProvidedDir != null && !userProvidedDir.trim().isEmpty()) {

			path = userProvidedDir;
			logger.debug("Read PDB dir from system property {}: {}", propertyName, path);
			File f = new File(path);
			if (!f.isDirectory()) {
				logger.warn(
						"Provided path {} (with system property {}) is not a directory. Using system's temp directory instead {}",
						path, propertyName, System.getProperty(TMP_DIR));
				path = System.getProperty(TMP_DIR);
			} else if (!f.canWrite()) {
				logger.warn(
						"Provided path {} (with system property {}) is not writable. Will not be able to write cached files.",
						path, propertyName);
				// we don't require the PDB_DIR to be writable, so that it can be used with a pre-rsynced dir
				// thus if not writable, we only warn and go ahead using it
			}


		} else {
			Map env = System.getenv();

			if( env.containsKey(propertyName) && !env.get(propertyName).trim().isEmpty()) {
				path = env.get(propertyName);
				logger.debug("Read dir from environment variable {}: {}", propertyName, path);

				File f = new File(path);
				if (!f.isDirectory()) {
					logger.warn(
							"Provided path {} (with environment variable {}) is not a directory. Using system's temp directory instead {}",
							path, propertyName, System.getProperty(TMP_DIR));
					path = System.getProperty(TMP_DIR);
				} else if (!f.canWrite()) {
					logger.warn(
							"Provided path {} (with environment variable {}) is not writable. Will not be able to write cached files",
							path, propertyName);
					// we don't require the PDB_DIR to be writable, so that it can be used with a pre-rsynced dir
					// thus if not writable, we only warn and go ahead using it
				}

			} else {
				path = System.getProperty(TMP_DIR);

				if ( ! warningShown.get()) {

					logger.warn("Could not read dir from system property {} or environment variable {}, "
									+ "using system's temp directory {}",
							propertyName, propertyName, path);

					warningShown.set(true);
				}

				System.setProperty(propertyName,path);
			}
		}

		if ( ! path.endsWith(lineSplit) )
			path = path + lineSplit;

		return path;

	}

	private String initCacheFilePath() {

		String path = null;

		String propertyName = PDB_CACHE_DIR;

		String userProvidedDir = System.getProperty(propertyName);

		if ( userProvidedDir != null ) {

			path = userProvidedDir;
			logger.debug("Read cache dir from system property {}: {}", propertyName, path);
			File f = new File(path);
			if (!f.isDirectory()) {
				logger.warn(
						"Provided path {} (with system property {}) is not a directory. Using system's temp directory instead {}",
						path, propertyName, System.getProperty(TMP_DIR));
				path = System.getProperty(TMP_DIR);
			} else if (!f.canWrite()) {
				logger.warn(
						"Provided path {} (with system property {}) is not writable. Using system's temp directory instead {}",
						path, propertyName, System.getProperty(TMP_DIR));
				path = System.getProperty(TMP_DIR);
				System.setProperty(propertyName,path);
			}


		} else {
			Map env = System.getenv();

			if( env.containsKey(propertyName)) {
				path = env.get(propertyName);
				logger.debug("Read dir from environment variable {}: {}", propertyName, path);

				File f = new File(path);
				if (!f.isDirectory()) {
					logger.warn(
							"Provided path {} (with environment variable {}) is not a directory. Using system's temp directory instead {}",
							path, propertyName, System.getProperty(TMP_DIR));
					path = System.getProperty(TMP_DIR);
				} else if (!f.canWrite()) {
					logger.warn(
							"Provided path {} (with environment variable {}) is not writable. Using system's temp directory instead {}",
							path, propertyName, System.getProperty(TMP_DIR));
					path = System.getProperty(TMP_DIR);
				}

			} else {
				// NOTE in case of not provided, then it is set to same as pdbFilePath
				// as PDB_DIR is not checked for being writable, we have to do that check here in case
				if (new File(pdbFilePath).canWrite()){
					path = pdbFilePath;
					logger.info("Could not read cache dir from system property {} or environment variable {}, "
							+ "using PDB directory instead {}",
							propertyName, propertyName, path);
					System.setProperty(propertyName,path);

				} else {
					path = System.getProperty(TMP_DIR);
					logger.warn("Could not read cache dir from system property {} or environment variable {}, "
							+ "and PDB directory {} is not writable. Using system's temp directory instead {}",
							propertyName, propertyName, pdbFilePath, path);
					System.setProperty(propertyName,path);

				}
			}
		}

		if ( ! path.endsWith(lineSplit) )
			path = path + lineSplit;

		return path;

	}

	public String getPdbFilePath()
	{
		return pdbFilePath;
	}

	public void setPdbFilePath(String pdbFilePath)
	{
		this.pdbFilePath = pdbFilePath;
	}

	public String getCacheFilePath() {
		return cacheFilePath;
	}

	public void setCacheFilePath(String cacheFilePath) {
		this.cacheFilePath = cacheFilePath;
	}

	public FetchBehavior getFetchBehavior() {
		return fetchBehavior;
	}

	public void setFetchBehavior(FetchBehavior fetchBehavior) {
		this.fetchBehavior = fetchBehavior;
	}

	public ObsoleteBehavior getObsoleteBehavior() {
		return obsoleteBehavior;
	}

	public void setObsoleteBehavior(ObsoleteBehavior obsoleteBehavior) {
		this.obsoleteBehavior = obsoleteBehavior;
	}

	/** convert Configuration to an XML file so it can be serialized
	 *
	 * @param pw
	 * @return XMLWriter
	 * @throws IOException
	 */
	public XMLWriter toXML(PrintWriter pw)
			throws IOException
			{

		XMLWriter     xw = new PrettyXMLWriter( pw);

		toXML(xw);
		return xw ;
			}


	/** convert Configuration to an XML file so it can be serialized
	 * add to an already existing xml file.
	 *
	 * @param xw the XML writer to use
	 * @return the writer again
	 * @throws IOException
	 * @see org.biojava.nbio.structure.align.webstart.ConfigXMLHandler
	 */

	public XMLWriter toXML(XMLWriter xw)
			throws IOException
			{
		xw.printRaw("");
		//xw.printRaw("");
		xw.openTag("JFatCatConfig");

		xw.openTag("PDBFILEPATH");
		// we don;t serialize the tempdir...
		String tempdir = System.getProperty(TMP_DIR);
		if (! pdbFilePath.equals(tempdir))
			xw.attribute("path", pdbFilePath);

		xw.attribute("fetchBehavior", fetchBehavior+"");
		xw.attribute("obsoleteBehavior", obsoleteBehavior+"");
		xw.attribute("fileFormat", fileFormat);
		xw.closeTag("PDBFILEPATH");

		xw.closeTag("JFatCatConfig");
		return xw ;

			}

	public static UserConfiguration fromStartupParams(StartupParameters params) {
		UserConfiguration config = new UserConfiguration();
		config.setPdbFilePath(params.getPdbFilePath());

		if(params.isAutoFetch()) {
			config.setFetchBehavior(FetchBehavior.DEFAULT);
		} else {
			config.setFetchBehavior(FetchBehavior.LOCAL_ONLY);
		}

		// TODO support MMCif Files
		config.setFileFormat(UserConfiguration.PDB_FORMAT);
		return config;
	}

	public void setFileFormat (String fileFormat){
		this.fileFormat = fileFormat;
	}

	public String getFileFormat()
	{
		return fileFormat;
	}

	public StructureFiletype getStructureFiletype() {
		switch (fileFormat) {
			case MMCIF_FORMAT:
				return StructureFiletype.CIF;
			case PDB_FORMAT:
				return StructureFiletype.PDB;
			case MMTF_FORMAT:
				return StructureFiletype.MMTF;
			case BCIF_FORMAT:
			default:
				return StructureFiletype.BCIF;
		}
	}
}