Merge branch 'features/JAL-1605_html-svg-export' into develop
[jalview.git] / src / jalview / ws / ebi / EBIFetchClient.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2)
3  * Copyright (C) 2014 The Jalview Authors
4  * 
5  * This file is part of Jalview.
6  * 
7  * Jalview is free software: you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License 
9  * as published by the Free Software Foundation, either version 3
10  * of the License, or (at your option) any later version.
11  *  
12  * Jalview is distributed in the hope that it will be useful, but 
13  * WITHOUT ANY WARRANTY; without even the implied warranty 
14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
15  * PURPOSE.  See the GNU General Public License for more details.
16  * 
17  * You should have received a copy of the GNU General Public License
18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
19  * The Jalview Authors are detailed in the 'AUTHORS' file.
20  */
21 package jalview.ws.ebi;
22
23 import jalview.util.MessageManager;
24
25 import java.io.BufferedInputStream;
26 import java.io.BufferedReader;
27 import java.io.File;
28 import java.io.FileOutputStream;
29 import java.io.InputStreamReader;
30 import java.net.URL;
31 import java.util.ArrayList;
32 import java.util.StringTokenizer;
33
34 /**
35  * DOCUMENT ME!
36  * 
37  * @author $author$
38  * @version $Revision$
39  */
40 public class EBIFetchClient
41 {
42   String format = "default";
43
44   String style = "raw";
45
46   /**
47    * Creates a new EBIFetchClient object.
48    */
49   public EBIFetchClient()
50   {
51   }
52
53   /**
54    * DOCUMENT ME!
55    * 
56    * @return DOCUMENT ME!
57    */
58   public String[] getSupportedDBs()
59   {
60     // TODO - implement rest call for dbfetch getSupportedDBs
61     throw new Error(MessageManager.getString("error.not_yet_implemented"));
62   }
63
64   /**
65    * DOCUMENT ME!
66    * 
67    * @return DOCUMENT ME!
68    */
69   public String[] getSupportedFormats()
70   {
71     // TODO - implement rest call for dbfetch getSupportedFormats
72     throw new Error(MessageManager.getString("error.not_yet_implemented"));
73   }
74
75   /**
76    * DOCUMENT ME!
77    * 
78    * @return DOCUMENT ME!
79    */
80   public String[] getSupportedStyles()
81   {
82     // TODO - implement rest call for dbfetch getSupportedStyles
83     throw new Error(MessageManager.getString("error.not_yet_implemented"));
84   }
85
86   public File fetchDataAsFile(String ids, String f, String s)
87           throws OutOfMemoryError
88   {
89     File outFile = null;
90     try
91     {
92       outFile = File.createTempFile("jalview", ".xml");
93       outFile.deleteOnExit();
94       fetchData(ids, f, s, outFile);
95       if (outFile.length() == 0)
96       {
97         outFile.delete();
98         return null;
99       }
100     } catch (Exception ex)
101     {
102     }
103     return outFile;
104   }
105
106   /**
107    * Single DB multiple record retrieval
108    * 
109    * @param ids
110    *          db:query1;query2;query3
111    * @param f
112    *          raw/xml
113    * @param s
114    *          ?
115    * 
116    * @return Raw string array result of query set
117    */
118   public String[] fetchData(String ids, String f, String s)
119           throws OutOfMemoryError
120   {
121     return fetchData(ids, f, s, null);
122   }
123
124   public String[] fetchData(String ids, String f, String s, File outFile)
125           throws OutOfMemoryError
126   {
127     // Need to split
128     // ids of the form uniprot:25KD_SARPE;ADHR_DROPS;
129     String[] rslts = new String[0];
130     StringTokenizer queries = new StringTokenizer(ids, ";");
131     String db = null;
132     StringBuffer querystring = null;
133     int nq = 0;
134     while (queries.hasMoreTokens())
135     {
136       String query = queries.nextToken();
137       int p;
138       if ((p = query.indexOf(':')) > -1)
139       {
140         db = query.substring(0, p);
141         query = query.substring(p + 1);
142       }
143       if (querystring == null)
144       {
145         querystring = new StringBuffer(query);
146         nq++;
147       }
148       else
149       {
150         querystring.append("," + query);
151         nq++;
152       }
153     }
154     if (db == null)
155     {
156       System.err.println("Invalid Query string : '" + ids
157               + "'\nShould be of form 'dbname:q1;q2;q3;q4'");
158       return null;
159     }
160     String[] rslt = fetchBatch(querystring.toString(), db, f, s, outFile);
161     if (rslt != null)
162     {
163       String[] nrslts = new String[rslt.length + rslts.length];
164       System.arraycopy(rslts, 0, nrslts, 0, rslts.length);
165       System.arraycopy(rslt, 0, nrslts, rslts.length, rslt.length);
166       rslts = nrslts;
167     }
168
169     return (rslts.length == 0 ? null : rslts);
170   }
171
172   public String[] fetchBatch(String ids, String db, String f, String s,
173           File outFile) throws OutOfMemoryError
174   {
175     long time = System.currentTimeMillis();
176     // max 200 ids can be added at one time
177     try
178     {
179       URL rcall = new URL("http://www.ebi.ac.uk/Tools/dbfetch/dbfetch/"
180               + db.toLowerCase() + "/" + ids.toLowerCase()
181               + (f != null ? "/" + f : ""));
182
183       BufferedInputStream is = new BufferedInputStream(rcall.openStream());
184       if (outFile != null)
185       {
186         FileOutputStream fio = new FileOutputStream(outFile);
187         byte[] bb = new byte[32 * 1024];
188         int l;
189         while ((l = is.read(bb)) > 0)
190         {
191           fio.write(bb, 0, l);
192         }
193         fio.close();
194         is.close();
195       }
196       else
197       {
198         BufferedReader br = new BufferedReader(new InputStreamReader(is));
199         String rtn;
200         ArrayList<String> arl = new ArrayList<String>();
201         while ((rtn = br.readLine()) != null)
202         {
203           arl.add(rtn);
204         }
205         return arl.toArray(new String[arl.size()]);
206       }
207     } catch (OutOfMemoryError er)
208     {
209
210       System.out.println("OUT OF MEMORY DOWNLOADING QUERY FROM " + db
211               + ":\n" + ids);
212       throw er;
213     } catch (Exception ex)
214     {
215       if (ex.getMessage().startsWith(
216               "uk.ac.ebi.jdbfetch.exceptions.DbfNoEntryFoundException"))
217       {
218         return null;
219       }
220       System.err.println("Unexpected exception when retrieving from " + db
221               + "\nQuery was : '" + ids + "'");
222       ex.printStackTrace(System.err);
223       return null;
224     } finally
225     {
226       // System.err.println("Took " + (System.currentTimeMillis() - time)
227       // / 1000 + " secs for one call.");
228     }
229     return null;
230   }
231 }