Java tutorial
/* * Genoogle: Similar DNA Sequences Searching Engine and Tools. (http://genoogle.pih.bio.br) * Copyright (C) 2008,2009 Felipe Fernandes Albrecht (felipe.albrecht@gmail.com) * * For further information check the LICENSE file. */ package bio.pih.genoogle.io; import java.io.File; import java.io.IOException; import java.util.Iterator; import java.util.List; import org.apache.log4j.Logger; import org.dom4j.Document; import org.dom4j.Element; import org.dom4j.io.SAXReader; import bio.pih.genoogle.Genoogle; import bio.pih.genoogle.index.ValueOutOfBoundsException; import bio.pih.genoogle.search.SearchManager; import bio.pih.genoogle.seq.Alphabet; import bio.pih.genoogle.seq.AminoAcidAlphabet; import bio.pih.genoogle.seq.DNAAlphabet; import bio.pih.genoogle.seq.RNAAlphabet; import com.google.common.collect.Lists; /** * Read and execute the configuration from a the XML file. * * @author albrecht */ public class XMLConfigurationReader { private static Logger logger = Logger.getLogger(XMLConfigurationReader.class.getCanonicalName()); private static File confFile = new File(Genoogle.getHome(), "conf" + File.separator + "genoogle.xml"); private static Document doc = null; static { try { doc = new SAXReader().read(confFile); } catch (Exception e) { logger.fatal("Error reading the configuration at " + confFile + "."); logger.fatal(e); } } /** * @return a brand new {@link SearchManager} with the parameters read from * genoogle.xml and with its data banks. */ public static SearchManager getSearchManager() throws IOException, ValueOutOfBoundsException, InvalidConfigurationException { Element rootElement = doc.getRootElement(); Element searchManagerElement = rootElement.element("search-manager"); SearchManager searchManager = new SearchManager(getMaxSimultaneousSearchs(searchManagerElement)); List<AbstractSequenceDataBank> dataBanks = XMLConfigurationReader.getDataBanks(); for (AbstractSequenceDataBank dataBank : dataBanks) { if (dataBank.load()) { searchManager.addDatabank(dataBank); } else { logger.fatal("It was not possible to load the data bank \"" + dataBank.getName() + "\"."); } } return searchManager; } /** * @return how many simultaneous searchs a searchManager can handle. */ private static int getMaxSimultaneousSearchs(Element searchManager) { Element maxSimultaneousSearchs = searchManager.element("max-simultaneous-searchs"); String value = maxSimultaneousSearchs.attributeValue("value"); return Integer.parseInt(value); } private static Integer match = null; private static Integer mismatch = null; public static int getMatchScore() { if (match == null) { Element rootElement = doc.getRootElement(); Element scoreElement = rootElement.element("score"); Element matchElement = scoreElement.element("match"); String value = matchElement.attributeValue("value"); match = Integer.parseInt(value); } return match.intValue(); } public static int getMismatchScore() { if (mismatch == null) { Element rootElement = doc.getRootElement(); Element scoreElement = rootElement.element("score"); Element mismatchElement = scoreElement.element("mismatch"); String value = mismatchElement.attributeValue("value"); mismatch = Integer.parseInt(value); } return mismatch.intValue(); } /** * @return {@link List} of {@link AbstractSequenceDataBank} that are * configured in the XML file. */ @SuppressWarnings("unchecked") public static List<AbstractSequenceDataBank> getDataBanks() throws IOException, InvalidConfigurationException { Element rootElement = doc.getRootElement(); Element databanks = rootElement.element("databanks"); if (databanks == null) { return null; } List<AbstractSequenceDataBank> sequenceDataBanks = Lists.newLinkedList(); Iterator<AbstractSimpleSequenceDataBank> databankIterator = databanks.elementIterator(); while (databankIterator.hasNext()) { AbstractSequenceDataBank databank = getDatabank((Element) databankIterator.next(), null); if (databank == null) { return null; } sequenceDataBanks.add(databank); } return sequenceDataBanks; } private static AbstractSequenceDataBank getDatabank(Element e, AbstractDatabankCollection<? extends AbstractSimpleSequenceDataBank> parent) throws IOException, InvalidConfigurationException { String name = e.attributeValue("name"); String path = readPath(e.attributeValue("path")); String mask = e.attributeValue("mask"); String lowComplexityFilterString = e.attributeValue("low-complexity-filter"); String type = e.attributeValue("type"); String remoteSimilarity = e.attributeValue("remoteSimilarity"); boolean remoteSimilarityDatabank = false; if (remoteSimilarity != null) { remoteSimilarityDatabank = Boolean.parseBoolean(remoteSimilarity); } String subSequenceLengthString = e.attributeValue("sub-sequence-length"); int subSequenceLength; if (parent != null) { subSequenceLength = parent.getSubSequenceLength(); } else { subSequenceLength = Integer.parseInt(subSequenceLengthString); } if (name == null) { throw new InvalidConfigurationException("Missing attribute name in element " + e.getName()); } if (path == null) { throw new InvalidConfigurationException("Missing attribute path in element " + e.getName()); } if (path.equals(name)) { throw new InvalidConfigurationException("It is not possible to have a FASTA file (" + path + ") with the same name (" + name + ") of the data base."); } if ((parent != null) && path.equals(parent.getName())) { throw new InvalidConfigurationException("It is not possible to have a FASTA (" + path + ") file with the same name (" + parent.getName() + ") of the its parent data bank."); } int lowComplexityFilter = -1; if (lowComplexityFilterString != null) { lowComplexityFilter = Integer.parseInt(lowComplexityFilterString); } Alphabet alphabet = DNAAlphabet.SINGLETON; if (type != null) { if (type.toLowerCase().equals("dna")) { alphabet = DNAAlphabet.SINGLETON; } else if (type.toLowerCase().equals("rna")) { alphabet = RNAAlphabet.SINGLETON; } else if (type.toLowerCase().equals("protein")) { alphabet = AminoAcidAlphabet.SINGLETON; } else { throw new InvalidConfigurationException("Sequences type: " + type + " is invalid."); } } else { if (parent != null) { alphabet = parent.getAlphabet(); } } if (e.getName().trim().equals("split-databanks")) { String numberOfSubDatabanksAttr = e.attributeValue("number-of-sub-databanks"); if (numberOfSubDatabanksAttr == null) { throw new RuntimeException("Missing atribute 'number-of-sub-databanks' in the databank " + name); } int size = Integer.parseInt(numberOfSubDatabanksAttr); SplittedDatabankCollection splittedSequenceDatabank = new SplittedDatabankCollection(name, alphabet, new File(Genoogle.getHome(), path), subSequenceLength, size, mask); splittedSequenceDatabank.setLowComplexityFilter(lowComplexityFilter); Iterator databankIterator = e.elementIterator(); while (databankIterator.hasNext()) { try { IndexedSequenceDataBank databank = (IndexedSequenceDataBank) getDatabank( (Element) databankIterator.next(), splittedSequenceDatabank); if (databank == null) { return null; } splittedSequenceDatabank.addDatabank(databank); } catch (DuplicateDatabankException e1) { logger.fatal("Duplicate databanks named " + e1.getDatabankName() + " defined in " + e1.getDatabankName(), e1); return null; } } return splittedSequenceDatabank; } else if (e.getName().trim().equals("databank")) { File file = new File(path); try { if (remoteSimilarityDatabank == false) { return new IndexedSequenceDataBank(name, alphabet, subSequenceLength, mask, file, parent); } else { return new RemoteSimilaritySequenceDataBank(name, alphabet, subSequenceLength, file, parent); } } catch (ValueOutOfBoundsException e1) { logger.fatal("Error creating IndexedDNASequenceDataBank.", e1); } return null; } logger.error("Unknow element name " + e.getName()); return null; } private static Element getSearchParameters() { return doc.getRootElement().element("search-parameters"); } /** * @return max SubSequence distance */ public static int getMaxSubSequenceDistance() { String value = getSearchParameters().element("max-sub-sequence-distance").attributeValue("value"); return Integer.parseInt(value); } /** * @return default extended drop off specified at the XML configuration * file. */ public static int getExtendDropoff() { String value = getSearchParameters().element("extend-dropoff").attributeValue("value"); return Integer.parseInt(value); } /** * @return default minimum length of a HSP to be keep to the next seaching * phase. */ public static int getMinHspLength() { String value = getSearchParameters().element("min-hsp-length").attributeValue("value"); return Integer.parseInt(value); } /** * @return how many Hits results. */ public static int getMaxResults() { String value = getSearchParameters().element("max-hits-results").attributeValue("value"); return Integer.parseInt(value); } /** * @return Max number of threads that will be used to search sub-sequences * at the index. */ public static int getMaxThreadsIndexSearch() { String value = getSearchParameters().element("max-threads-index-search").attributeValue("value"); return Integer.parseInt(value); } /** * @return Max number of threads that will be used to extend and align the * HSP. */ public static int getMaxThreadsExtendAlign() { String value = getSearchParameters().element("max-threads-extend-align").attributeValue("value"); return Integer.parseInt(value); } /** * @return minimum size of each input query slice. */ public static int getMinQuerySliceLength() { String value = getSearchParameters().element("min-query-slice-length").attributeValue("value"); return Integer.parseInt(value); } /** * @return how many slices the input query will be divided. */ public static int getQuerySplitQuantity() { String value = getSearchParameters().element("query-split-quantity").attributeValue("value"); return Integer.parseInt(value); } private static String readPath(String path) { return path.replace('/', File.separatorChar); } private static Element getWebService() { return doc.getRootElement().element("web-service"); } public static String getWebServiceAddress() { return getWebService().element("server-address").attributeValue("value"); } public static Boolean useSessions() { String value = getWebService().element("use-sessions").attributeValue("value"); return Boolean.parseBoolean(value); } }