JAL-1687 ignore case when determining if sequence matches consensus
[jalview.git] / src / jalview / ws / AWSThread.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3  * Copyright (C) $$Year-Rel$$ 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;
22
23 import jalview.bin.Cache;
24 import jalview.datamodel.AlignedCodonFrame;
25 import jalview.datamodel.Alignment;
26 import jalview.datamodel.AlignmentI;
27 import jalview.datamodel.AlignmentView;
28 import jalview.datamodel.SequenceI;
29 import jalview.gui.AlignFrame;
30 import jalview.gui.WebserviceInfo;
31 import jalview.util.MessageManager;
32 import jalview.viewmodel.seqfeatures.FeatureRendererSettings;
33
34 import java.util.LinkedHashSet;
35 import java.util.Set;
36
37 public abstract class AWSThread extends Thread
38 {
39
40   /**
41    * view that this job was associated with
42    */
43   protected AlignmentI currentView = null;
44
45   /**
46    * feature settings from view that job was associated with
47    */
48   protected FeatureRendererSettings featureSettings = null;
49
50   /**
51    * metadata about this web service
52    */
53   protected WebserviceInfo wsInfo = null;
54
55   /**
56    * original input data for this job
57    */
58   protected AlignmentView input = null;
59
60   /**
61    * dataset sequence relationships to be propagated onto new results
62    */
63   protected Set<AlignedCodonFrame> codonframe = null;
64
65   /**
66    * are there jobs still running in this thread.
67    */
68   protected boolean jobComplete = false;
69
70   /**
71    * one or more jobs being managed by this thread.
72    */
73   protected AWsJob jobs[] = null;
74
75   /**
76    * full name of service
77    */
78   protected String WebServiceName = null;
79
80   protected char defGapChar = '-';
81
82   /**
83    * header prepended to all output from job
84    */
85   protected String OutputHeader;
86
87   /**
88    * only used when reporting a web service out of memory error - the job ID
89    * will be concatenated to the URL
90    */
91   protected String WsUrl = null;
92
93   /*
94    * The AlignFrame from which the service was requested.
95    */
96   private AlignFrame alignFrame;
97
98   /**
99    * generic web service job/subjob poll loop
100    */
101   public void run()
102   {
103     JobStateSummary jstate = null;
104     if (jobs == null)
105     {
106       jobComplete = true;
107     }
108     while (!jobComplete)
109     {
110       jstate = new JobStateSummary();
111       for (int j = 0; j < jobs.length; j++)
112       {
113
114         if (!jobs[j].submitted && jobs[j].hasValidInput())
115         {
116           StartJob(jobs[j]);
117         }
118
119         if (jobs[j].submitted && !jobs[j].subjobComplete)
120         {
121           try
122           {
123             pollJob(jobs[j]);
124             if (!jobs[j].hasResponse())
125             {
126               throw (new Exception(
127                       "Timed out when communicating with server\nTry again later.\n"));
128             }
129             jalview.bin.Cache.log.debug("Job " + j + " Result state "
130                     + jobs[j].getState() + "(ServerError="
131                     + jobs[j].isServerError() + ")");
132           } catch (Exception ex)
133           {
134             // Deal with Transaction exceptions
135             wsInfo.appendProgressText(jobs[j].jobnum, MessageManager
136                     .formatMessage("info.server_exception", new Object[]
137                     { WebServiceName, ex.getMessage() }));
138             // always output the exception's stack trace to the log
139             Cache.log.warn(WebServiceName + " job(" + jobs[j].jobnum
140                     + ") Server exception.");
141             // todo: could limit trace to cause if this is a SOAPFaultException.
142             ex.printStackTrace();
143
144             if (jobs[j].allowedServerExceptions > 0)
145             {
146               jobs[j].allowedServerExceptions--;
147               Cache.log.debug("Sleeping after a server exception.");
148               try
149               {
150                 Thread.sleep(5000);
151               } catch (InterruptedException ex1)
152               {
153               }
154             }
155             else
156             {
157               Cache.log.warn("Dropping job " + j + " " + jobs[j].jobId);
158               jobs[j].subjobComplete = true;
159               wsInfo.setStatus(jobs[j].jobnum,
160                       WebserviceInfo.STATE_STOPPED_SERVERERROR);
161             }
162           } catch (OutOfMemoryError er)
163           {
164             jobComplete = true;
165             jobs[j].subjobComplete = true;
166             jobs[j].clearResponse(); // may contain out of date result data
167             wsInfo.setStatus(jobs[j].jobnum,
168                     WebserviceInfo.STATE_STOPPED_ERROR);
169             Cache.log.error("Out of memory when retrieving Job " + j
170                     + " id:" + WsUrl + "/" + jobs[j].jobId, er);
171             new jalview.gui.OOMWarning("retrieving result for "
172                     + WebServiceName, er);
173             System.gc();
174           }
175         }
176         jstate.updateJobPanelState(wsInfo, OutputHeader, jobs[j]);
177       }
178       // Decide on overall state based on collected jobs[] states
179       updateGlobalStatus(jstate);
180       if (!jobComplete)
181       {
182         try
183         {
184           Thread.sleep(5000);
185         } catch (InterruptedException e)
186         {
187           Cache.log
188                   .debug("Interrupted sleep waiting for next job poll.", e);
189         }
190         // System.out.println("I'm alive "+alTitle);
191       }
192     }
193     if (jobComplete && jobs != null)
194     {
195       parseResult(); // tidy up and make results available to user
196     }
197     else
198     {
199       Cache.log
200               .debug("WebServiceJob poll loop finished with no jobs created.");
201       wsInfo.setStatus(WebserviceInfo.STATE_STOPPED_ERROR);
202       wsInfo.appendProgressText(MessageManager.getString("info.no_jobs_ran"));
203       wsInfo.setFinishedNoResults();
204     }
205   }
206
207   protected void updateGlobalStatus(JobStateSummary jstate)
208   {
209     if (jstate.running > 0)
210     {
211       wsInfo.setStatus(WebserviceInfo.STATE_RUNNING);
212     }
213     else if (jstate.queuing > 0)
214     {
215       wsInfo.setStatus(WebserviceInfo.STATE_QUEUING);
216     }
217     else
218     {
219       jobComplete = true;
220       if (jstate.finished > 0)
221       {
222         wsInfo.setStatus(WebserviceInfo.STATE_STOPPED_OK);
223       }
224       else if (jstate.error > 0)
225       {
226         wsInfo.setStatus(WebserviceInfo.STATE_STOPPED_ERROR);
227       }
228       else if (jstate.serror > 0)
229       {
230         wsInfo.setStatus(WebserviceInfo.STATE_STOPPED_SERVERERROR);
231       }
232     }
233   }
234
235   public AWSThread()
236   {
237     super();
238   }
239
240   public AWSThread(Runnable target)
241   {
242     super(target);
243   }
244
245   public AWSThread(String name)
246   {
247     super(name);
248   }
249
250   public AWSThread(ThreadGroup group, Runnable target)
251   {
252     super(group, target);
253   }
254
255   public AWSThread(ThreadGroup group, String name)
256   {
257     super(group, name);
258   }
259
260   public AWSThread(Runnable target, String name)
261   {
262     super(target, name);
263   }
264
265   public AWSThread(ThreadGroup group, Runnable target, String name)
266   {
267     super(group, target, name);
268   }
269
270   /**
271    * query web service for status of job. on return, job.result must not be null
272    * - if it is then it will be assumed that the job status query timed out and
273    * a server exception will be logged.
274    * 
275    * @param job
276    * @throws Exception
277    *           will be logged as a server exception for this job
278    */
279   public abstract void pollJob(AWsJob job) throws Exception;
280
281   /**
282    * submit job to web service
283    * 
284    * @param job
285    */
286   public abstract void StartJob(AWsJob job);
287
288   /**
289    * process the set of AWsJob objects into a set of results, and tidy up.
290    */
291   public abstract void parseResult();
292
293   /**
294    * helper function to conserve dataset references to sequence objects returned
295    * from web services 1. Propagates AlCodonFrame data from
296    * <code>codonframe</code> to <code>al</code> TODO: refactor to datamodel
297    * 
298    * @param al
299    */
300   public void propagateDatasetMappings(Alignment al)
301   {
302     if (codonframe != null)
303     {
304       SequenceI[] alignment = al.getSequencesArray();
305       for (int sq = 0; sq < alignment.length; sq++)
306       {
307         for (AlignedCodonFrame acf : codonframe)
308         {
309           final SequenceI seq = alignment[sq];
310           if (acf != null && acf.involvesSequence(seq))
311           {
312             al.addCodonFrame(acf);
313             break;
314           }
315         }
316       }
317     }
318   }
319
320   public AWSThread(ThreadGroup group, Runnable target, String name,
321           long stackSize)
322   {
323     super(group, target, name, stackSize);
324   }
325
326   /**
327    * 
328    * @return gap character to use for any alignment generation
329    */
330   public char getGapChar()
331   {
332     return defGapChar;
333   }
334
335   /**
336    * 
337    * @param alignFrame
338    *          reference for copying mappings across
339    * @param wsInfo
340    *          gui attachment point
341    * @param input
342    *          input data for the calculation
343    * @param webServiceName
344    *          name of service
345    * @param wsUrl
346    *          url of the service being invoked
347    */
348   public AWSThread(AlignFrame alignFrame, WebserviceInfo wsinfo,
349           AlignmentView input, String webServiceName, String wsUrl)
350   {
351     this(alignFrame, wsinfo, input, wsUrl);
352     WebServiceName = webServiceName;
353   }
354
355   /**
356    * Extracts additional info from alignment view's context.
357    * 
358    * @param alframe
359    *          - reference for copying mappings and display styles across
360    * @param wsinfo2
361    *          - gui attachment point - may be null
362    * @param alview
363    *          - input data for the calculation
364    * @param wsurl2
365    *          - url of the service being invoked
366    */
367   public AWSThread(AlignFrame alframe, WebserviceInfo wsinfo2,
368           AlignmentView alview, String wsurl2)
369   {
370     super();
371     this.alignFrame = alframe;
372     currentView = alframe.getCurrentView().getAlignment();
373     featureSettings = alframe.getFeatureRenderer().getSettings();
374     defGapChar = alframe.getViewport().getGapCharacter();
375     this.wsInfo = wsinfo2;
376     this.input = alview;
377     WsUrl = wsurl2;
378     if (alframe != null)
379     {
380       Set<AlignedCodonFrame> cf = alframe.getViewport().getAlignment()
381               .getCodonFrames();
382       if (cf != null)
383       {
384         codonframe = new LinkedHashSet<AlignedCodonFrame>();
385         codonframe.addAll(cf);
386       }
387     }
388   }
389
390   protected AlignFrame getRequestingAlignFrame()
391   {
392     return this.alignFrame;
393   }
394 }