src/org/biojava/dasobert/das/SequenceThread.java

   1 /*
   2  *                  BioJava development code
   3  *
   4  * This code may be freely distributed and modified under the
   5  * terms of the GNU Lesser General Public Licence.  This should
   6  * be distributed with the code.  If you do not have a copy,
   7  * see:
   8  *
   9  *      http://www.gnu.org/copyleft/lesser.html
  10  *
  11  * Copyright for this code is held jointly by the individual
  12  * authors.  These should be listed in @author doc comments.
  13  *
  14  * For more information on the BioJava project and its aims,
  15  * or to join the biojava-l mailing list, visit the home page
  16  * at:
  17  *
  18  *      http://www.biojava.org/
  19  *
  20  * Created on Nov 20, 2005
  21  *
  22  */
  23 package org.biojava.dasobert.das;
  24
  25 import java.io.InputStream;
  26 import java.net.HttpURLConnection;
  27 import java.net.URL;
  28 import java.util.Iterator;
  29 import java.util.logging.Level;
  30 import java.util.logging.Logger;
  31 import javax.xml.parsers.ParserConfigurationException;
  32 import javax.xml.parsers.SAXParser;
  33 import javax.xml.parsers.SAXParserFactory;
  34
  35 import org.biojava.dasobert.dasregistry.Das1Source;
  36 import org.biojava.dasobert.eventmodel.SequenceEvent;
  37 import org.biojava.dasobert.eventmodel.SequenceListener;
  38 import org.xml.sax.InputSource;
  39 import org.xml.sax.SAXException;
  40 import org.xml.sax.SAXNotRecognizedException;
  41 import org.xml.sax.XMLReader;
  42 import java.util.*;
  43
  44 /**
  45  * a thread that gets the sequence from a DAS server
  46  *
  47  * @author Andreas Prlic
  48  *
  49  */
  50 public class SequenceThread extends Thread
  51 {
  52
  53   Das1Source[] sequenceServers;
  54
  55   String sp_accession;
  56
  57   List seqListeners;
  58
  59   String version;
  60
  61   static Logger logger = Logger.getLogger("org.biojava.spice");
  62
  63   public SequenceThread(String sp_accession, Das1Source ds)
  64   {
  65     super();
  66     Das1Source[] dss = new Das1Source[1];
  67     dss[0] = ds;
  68     this.sp_accession = sp_accession;
  69     this.sequenceServers = dss;
  70     clearSequenceListeners();
  71     version = "";
  72   }
  73
  74   public SequenceThread(String sp_accession, Das1Source[] ds)
  75   {
  76     super();
  77
  78     this.sp_accession = sp_accession;
  79     this.sequenceServers = ds;
  80     clearSequenceListeners();
  81   }
  82
  83   public void clearSequenceListeners()
  84   {
  85     seqListeners = new ArrayList();
  86   }
  87
  88   public void addSequenceListener(SequenceListener lis)
  89   {
  90     seqListeners.add(lis);
  91   }
  92
  93   public void run()
  94   {
  95     getSequence();
  96   }
  97
  98   public void getSequence()
  99   {
 100
 101     boolean gotSequence = false;
 102
 103     for (int i = 0; i < sequenceServers.length; i++)
 104     {
 105
 106       if (gotSequence)
 107         break;
 108
 109       Das1Source ds = sequenceServers[i];
 110       String url = ds.getUrl();
 111       char lastChar = url.charAt(url.length() - 1);
 112       if (!(lastChar == '/'))
 113         url += "/";
 114       String dascmd = url + "sequence?segment=";
 115       String connstr = dascmd + sp_accession;
 116
 117       try
 118       {
 119         version = "";
 120
 121         String sequence = retrieveSequence(connstr);
 122         // bug in aristotle das source?
 123         sequence.replaceAll(" ", "");
 124         gotSequence = true;
 125         // set the sequence ...
 126
 127         triggerNewSequence(sp_accession, sequence, ds, version);
 128
 129         return;
 130       } catch (Exception ex)
 131       {
 132         ex.printStackTrace();
 133         logger.warning(ex.getMessage());
 134
 135         // triggerException(ex);
 136
 137       }
 138     }
 139
 140     logger
 141             .log(
 142                     Level.WARNING,
 143                     "could not retreive UniProt sequence from any available DAS sequence server");
 144
 145     triggerNoSequence(sp_accession);
 146
 147   }
 148
 149   // private void triggerException(Exception e){
 150   // Iterator iter = seqListeners.iterator();
 151   // while (iter.hasNext()){
 152   // SequenceListener li = (SequenceListener)iter.next();
 153   // li.exceptionOccured(e);
 154   // }
 155   // }
 156
 157   private void triggerNewSequence(String sp_accession, String sequence,
 158           Das1Source source, String version)
 159   {
 160
 161     Iterator iter = seqListeners.iterator();
 162     while (iter.hasNext())
 163     {
 164       SequenceListener li = (SequenceListener) iter.next();
 165       // SequenceEvent event = new SequenceEvent(sequence);
 166       SequenceEvent event = new SequenceEvent(sp_accession, sequence,
 167               version);
 168       event.setSource(source);
 169       li.newSequence(event);
 170     }
 171   }
 172
 173   private void triggerNoSequence(String ac)
 174   {
 175
 176     Iterator iter = seqListeners.iterator();
 177     while (iter.hasNext())
 178     {
 179       SequenceListener li = (SequenceListener) iter.next();
 180       li.noObjectFound(ac);
 181     }
 182
 183   }
 184
 185   /**
 186    * retrieve the Sequence from a DAS server.
 187    *
 188    * @param connstr -
 189    *                the DAS - request string. e.g.
 190    *                http://www.ebi.ac.uk/das-srv/uniprot/das/aristotle/sequence?segment=P00280
 191    * @return the requested Sequence
 192    * @throws Exception
 193    */
 194   public String retrieveSequence(String connstr) throws Exception
 195   {
 196
 197     // logger.finest("trying: " + connstr) ;
 198     URL dasUrl = new URL(connstr);
 199     // DAS_httpConnector dhtp = new DAS_httpConnector() ;
 200     logger.info("requesting sequence from " + connstr);
 201     InputStream dasInStream = open(dasUrl);
 202
 203     SAXParserFactory spfactory = SAXParserFactory.newInstance();
 204
 205     // never do this
 206     // String vali = System.getProperty("XMLVALIDATION");
 207     String vali = "false";
 208     boolean validate = false;
 209     if ((vali != null) && (vali.equals("true")))
 210       validate = true;
 211     spfactory.setValidating(validate);
 212
 213     SAXParser saxParser = null;
 214
 215     try
 216     {
 217       saxParser = spfactory.newSAXParser();
 218     } catch (ParserConfigurationException e)
 219     {
 220       // e.printStackTrace();
 221       logger.log(Level.FINER, "Uncaught exception", e);
 222     }
 223
 224     XMLReader xmlreader = saxParser.getXMLReader();
 225
 226     try
 227     {
 228       xmlreader.setFeature("http://xml.org/sax/features/validation",
 229               validate);
 230     } catch (SAXException e)
 231     {
 232       logger.finer("Cannot set validation to " + validate);
 233       logger.log(Level.FINER, "Uncaught exception", e);
 234     }
 235
 236     try
 237     {
 238       xmlreader
 239               .setFeature(
 240                       "http://apache.org/xml/features/nonvalidating/load-external-dtd",
 241                       validate);
 242     } catch (SAXNotRecognizedException e)
 243     {
 244       // e.printStackTrace();
 245       logger.finer("Cannot set load-external-dtd to" + validate);
 246       logger.log(Level.FINER, "Uncaught exception", e);
 247       // System.err.println("Cannot set load-external-dtd to" + validate);
 248     }
 249
 250     // DAS_DNA_Handler cont_handle = new DAS_DNA_Handler() ;
 251     DAS_Sequence_Handler cont_handle = new DAS_Sequence_Handler();
 252     xmlreader.setContentHandler(cont_handle);
 253     xmlreader.setErrorHandler(new org.xml.sax.helpers.DefaultHandler());
 254     InputSource insource = new InputSource();
 255     insource.setByteStream(dasInStream);
 256
 257     xmlreader.parse(insource);
 258     String sequence = cont_handle.get_sequence();
 259     version = cont_handle.getVersion();
 260     // logger.finest("Got sequence from DAS: " +sequence);
 261
 262     logger.exiting(this.getClass().getName(), "retreiveSequence", sequence);
 263     return sequence;
 264   }
 265
 266   private InputStream open(URL url)
 267   {
 268     {
 269
 270       InputStream inStream = null;
 271       try
 272       {
 273
 274         HttpURLConnection huc = null;
 275
 276         huc = DAS_FeatureRetrieve.openHttpURLConnection(url);
 277
 278         logger.finest(huc.getResponseMessage());
 279
 280         inStream = huc.getInputStream();
 281
 282       } catch (Exception ex)
 283       {
 284         ex.printStackTrace();
 285         logger.log(Level.WARNING, "exception occured", ex);
 286       }
 287
 288       return inStream;
 289     }
 290
 291   }
 292
 293 }