JAL-972 JAL-1084 propagate reference to local authentication provider so it can be...
[jalview.git] / src / jalview / ws / jws1 / JPredThread.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.7)
3  * Copyright (C) 2011 J Procter, AM Waterhouse, J Engelhardt, LM Lui, G Barton, M Clamp, S Searle
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 of the License, or (at your option) any later version.
10  * 
11  * Jalview is distributed in the hope that it will be useful, but 
12  * WITHOUT ANY WARRANTY; without even the implied warranty 
13  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
14  * PURPOSE.  See the GNU General Public License for more details.
15  * 
16  * You should have received a copy of the GNU General Public License along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
17  */
18 package jalview.ws.jws1;
19
20 import java.util.*;
21
22 import jalview.analysis.*;
23 import jalview.bin.*;
24 import jalview.datamodel.*;
25 import jalview.gui.*;
26 import jalview.io.*;
27 import jalview.util.*;
28 import jalview.ws.AWsJob;
29 import jalview.ws.JobStateSummary;
30 import jalview.ws.WSClientI;
31 import vamsas.objects.simple.JpredResult;
32
33 class JPredThread extends JWS1Thread implements WSClientI
34 {
35   // TODO: put mapping between JPredJob input and input data here -
36   // JNetAnnotation adding is done after result parsing.
37   class JPredJob extends WSJob
38   {
39     // TODO: make JPredJob deal only with what was sent to and received from a
40     // JNet service
41     int[] predMap = null; // mapping from sequence(i) to the original
42
43     // sequence(predMap[i]) being predicted on
44
45     vamsas.objects.simple.Sequence sequence;
46
47     vamsas.objects.simple.Msfalignment msa;
48
49     java.util.Hashtable SequenceInfo = null;
50
51     int msaIndex = 0; // the position of the original sequence in the array of
52
53     // Sequences in the input object that this job holds a
54     // prediction for
55
56     /**
57      * 
58      * @return true if getResultSet will return a valid alignment and prediction
59      *         result.
60      */
61     public boolean hasResults()
62     {
63       if (subjobComplete && result != null && result.isFinished()
64               && ((JpredResult) result).getPredfile() != null
65               && ((JpredResult) result).getAligfile() != null)
66       {
67         return true;
68       }
69       return false;
70     }
71
72     public boolean hasValidInput()
73     {
74       if (sequence != null)
75       {
76         return true;
77       }
78       return false;
79     }
80
81     /**
82      * 
83      * @return null or Object[] { annotated alignment for this prediction,
84      *         ColumnSelection for this prediction} or null if no results
85      *         available.
86      * @throws Exception
87      */
88     public Object[] getResultSet() throws Exception
89     {
90       if (result == null || !result.isFinished())
91       {
92         return null;
93       }
94       Alignment al = null;
95       ColumnSelection alcsel = null;
96       int FirstSeq = -1; // the position of the query sequence in Alignment al
97
98       JpredResult result = (JpredResult) this.result;
99
100       jalview.bin.Cache.log.debug("Parsing output from JNet job.");
101       // JPredFile prediction = new JPredFile("C:/JalviewX/files/jpred.txt",
102       // "File");
103       jalview.io.JPredFile prediction = new jalview.io.JPredFile(
104               result.getPredfile(), "Paste");
105       SequenceI[] preds = prediction.getSeqsAsArray();
106       jalview.bin.Cache.log.debug("Got prediction profile.");
107
108       if ((this.msa != null) && (result.getAligfile() != null))
109       {
110         jalview.bin.Cache.log.debug("Getting associated alignment.");
111         // we ignore the returned alignment if we only predicted on a single
112         // sequence
113         String format = new jalview.io.IdentifyFile().Identify(
114                 result.getAligfile(), "Paste");
115
116         if (jalview.io.FormatAdapter.isValidFormat(format))
117         {
118           SequenceI sqs[];
119           if (predMap != null)
120           {
121             Object[] alandcolsel = input
122                     .getAlignmentAndColumnSelection(getGapChar());
123             sqs = (SequenceI[]) alandcolsel[0];
124             al = new Alignment(sqs);
125             alcsel = (ColumnSelection) alandcolsel[1];
126           }
127           else
128           {
129             al = new FormatAdapter().readFile(result.getAligfile(),
130                     "Paste", format);
131             sqs = new SequenceI[al.getHeight()];
132
133             for (int i = 0, j = al.getHeight(); i < j; i++)
134             {
135               sqs[i] = al.getSequenceAt(i);
136             }
137             if (!jalview.analysis.SeqsetUtils.deuniquify(
138                     (Hashtable) SequenceInfo, sqs))
139             {
140               throw (new Exception(
141                       "Couldn't recover sequence properties for alignment."));
142             }
143           }
144           FirstSeq = 0;
145           al.setDataset(null);
146
147           jalview.io.JnetAnnotationMaker.add_annotation(prediction, al,
148                   FirstSeq, false, predMap);
149
150         }
151         else
152         {
153           throw (new Exception("Unknown format " + format
154                   + " for file : \n" + result.getAligfile()));
155         }
156       }
157       else
158       {
159         al = new Alignment(preds);
160         FirstSeq = prediction.getQuerySeqPosition();
161         if (predMap != null)
162         {
163           char gc = getGapChar();
164           SequenceI[] sqs = (SequenceI[]) ((java.lang.Object[]) input
165                   .getAlignmentAndColumnSelection(gc))[0];
166           if (this.msaIndex >= sqs.length)
167           {
168             throw new Error(
169                     "Implementation Error! Invalid msaIndex for JPredJob on parent MSA input object!");
170           }
171
172           // ///
173           // Uses RemoveGapsCommand
174           // ///
175           new jalview.commands.RemoveGapsCommand("Remove Gaps",
176                   new SequenceI[]
177                   { sqs[msaIndex] }, currentView);
178
179           SequenceI profileseq = al.getSequenceAt(FirstSeq);
180           profileseq.setSequence(sqs[msaIndex].getSequenceAsString());
181         }
182
183         if (!jalview.analysis.SeqsetUtils.SeqCharacterUnhash(
184                 al.getSequenceAt(FirstSeq), SequenceInfo))
185         {
186           throw (new Exception(
187                   "Couldn't recover sequence properties for JNet Query sequence!"));
188         }
189         else
190         {
191           al.setDataset(null);
192           jalview.io.JnetAnnotationMaker.add_annotation(prediction, al,
193                   FirstSeq, true, predMap);
194           SequenceI profileseq = al.getSequenceAt(0); // this includes any gaps.
195           alignToProfileSeq(al, profileseq);
196           if (predMap != null)
197           {
198             // Adjust input view for gaps
199             // propagate insertions into profile
200             alcsel = ColumnSelection.propagateInsertions(profileseq, al, input);
201           }
202         }
203       }
204       return new Object[]
205       { al, alcsel }; // , FirstSeq, noMsa};
206     }
207
208     /**
209      * Given an alignment where all other sequences except profileseq are
210      * aligned to the ungapped profileseq, insert gaps in the other sequences to
211      * realign them with the residues in profileseq
212      * 
213      * @param al
214      * @param profileseq
215      */
216     private void alignToProfileSeq(Alignment al, SequenceI profileseq)
217     {
218       char gc = al.getGapCharacter();
219       int[] gapMap = profileseq.gapMap();
220       // insert gaps into profile
221       for (int lp = 0, r = 0; r < gapMap.length; r++)
222       {
223         if (gapMap[r] - lp > 1)
224         {
225           StringBuffer sb = new StringBuffer();
226           for (int s = 0, ns = gapMap[r] - lp; s < ns; s++)
227           {
228             sb.append(gc);
229           }
230           for (int s = 1, ns = al.getHeight(); s < ns; s++)
231           {
232             String sq = al.getSequenceAt(s).getSequenceAsString();
233             int diff = gapMap[r] - sq.length();
234             if (diff > 0)
235             {
236               // pad gaps
237               sq = sq + sb;
238               while ((diff = gapMap[r] - sq.length()) > 0)
239               {
240                 sq = sq
241                         + ((diff >= sb.length()) ? sb.toString() : sb
242                                 .substring(0, diff));
243               }
244               al.getSequenceAt(s).setSequence(sq);
245             }
246             else
247             {
248               al.getSequenceAt(s).setSequence(
249                       sq.substring(0, gapMap[r]) + sb.toString()
250                               + sq.substring(gapMap[r]));
251             }
252           }
253         }
254         lp = gapMap[r];
255       }
256     }
257
258
259     public JPredJob(Hashtable SequenceInfo, SequenceI seq, int[] delMap)
260     {
261       super();
262       this.predMap = delMap;
263       String sq = AlignSeq.extractGaps(Comparison.GapChars,
264               seq.getSequenceAsString());
265       if (sq.length() >= 20)
266       {
267         this.SequenceInfo = SequenceInfo;
268         sequence = new vamsas.objects.simple.Sequence();
269         sequence.setId(seq.getName());
270         sequence.setSeq(sq);
271       }
272     }
273
274     public JPredJob(Hashtable SequenceInfo, SequenceI[] msf, int[] delMap)
275     {
276       this(SequenceInfo, msf[0], delMap);
277       if (sequence != null)
278       {
279         if (msf.length > 1)
280         {
281           msa = new vamsas.objects.simple.Msfalignment();
282           jalview.io.PileUpfile pileup = new jalview.io.PileUpfile();
283           msa.setMsf(pileup.print(msf));
284         }
285       }
286     }
287   }
288
289   ext.vamsas.Jpred server;
290
291   String altitle = "";
292
293   JPredThread(WebserviceInfo wsinfo, String altitle,
294           ext.vamsas.Jpred server, String wsurl, AlignmentView alview,
295           AlignFrame alframe)
296   {
297     super(alframe, wsinfo, alview, wsurl);
298     this.altitle = altitle;
299     this.server = server;
300   }
301
302   JPredThread(WebserviceInfo wsinfo, String altitle,
303           ext.vamsas.Jpred server, String wsurl, Hashtable SequenceInfo,
304           SequenceI seq, int[] delMap, AlignmentView alview,
305           AlignFrame alframe)
306   {
307     this(wsinfo, altitle, server, wsurl, alview, alframe);
308     JPredJob job = new JPredJob(SequenceInfo, seq, delMap);
309     if (job.hasValidInput())
310     {
311       OutputHeader = wsInfo.getProgressText();
312       jobs = new WSJob[]
313       { job };
314       job.setJobnum(0);
315     }
316   }
317
318   JPredThread(WebserviceInfo wsinfo, String altitle,
319           ext.vamsas.Jpred server, Hashtable SequenceInfo, SequenceI[] msf,
320           int[] delMap, AlignmentView alview, AlignFrame alframe,
321           String wsurl)
322   {
323     this(wsinfo, altitle, server, wsurl, alview, alframe);
324     JPredJob job = new JPredJob(SequenceInfo, msf, delMap);
325     if (job.hasValidInput())
326     {
327       jobs = new WSJob[]
328       { job };
329       OutputHeader = wsInfo.getProgressText();
330       job.setJobnum(0);
331     }
332   }
333
334   public void StartJob(AWsJob j)
335   {
336     if (!(j instanceof JPredJob))
337     {
338       throw new Error(
339               "Implementation error - StartJob(JpredJob) called on "
340                       + j.getClass());
341     }
342     try
343     {
344       JPredJob job = (JPredJob) j;
345       if (job.msa != null)
346       {
347         job.setJobId(server.predictOnMsa(job.msa));
348       }
349       else if (job.sequence != null)
350       {
351         job.setJobId(server.predict(job.sequence)); // debug like : job.jobId =
352         // "/jobs/www-jpred/jp_Yatat29";//
353       }
354
355       if (job.getJobId() != null)
356       {
357         if (job.getJobId().startsWith("Broken"))
358         {
359           job.result = (vamsas.objects.simple.Result) new JpredResult();
360           job.result.setInvalid(true);
361           job.result.setStatus("Submission " + job.getJobId());
362           throw new Exception(job.getJobId());
363         }
364         else
365         {
366           job.setSubmitted(true);
367           job.setSubjobComplete(false);
368           Cache.log.info(WsUrl + " Job Id '" + job.getJobId() + "'");
369         }
370       }
371       else
372       {
373         throw new Exception("Server timed out - try again later\n");
374       }
375     } catch (Exception e)
376     {
377       // kill the whole job.
378       wsInfo.setStatus(WebserviceInfo.STATE_STOPPED_SERVERERROR);
379       if (e.getMessage().indexOf("Exception") > -1)
380       {
381         wsInfo.setStatus(j.getJobnum(),
382                 WebserviceInfo.STATE_STOPPED_SERVERERROR);
383         wsInfo.setProgressText(
384                 j.getJobnum(),
385                 "Failed to submit the prediction. (Just close the window)\n"
386                         + "It is most likely that there is a problem with the server.\n");
387         System.err
388                 .println("JPredWS Client: Failed to submit the prediction. Quite possibly because of a server error - see below)\n"
389                         + e.getMessage() + "\n");
390
391         jalview.bin.Cache.log.warn("Server Exception", e);
392       }
393       else
394       {
395         wsInfo.setStatus(j.getJobnum(), WebserviceInfo.STATE_STOPPED_ERROR);
396         // JBPNote - this could be a popup informing the user of the problem.
397         wsInfo.appendProgressText(j.getJobnum(),
398                 "Failed to submit the prediction:\n" + e.getMessage()
399                         + wsInfo.getProgressText());
400
401         jalview.bin.Cache.log.debug(
402                 "Failed Submission of job " + j.getJobnum(), e);
403
404       }
405       j.setAllowedServerExceptions(-1);
406       j.setSubjobComplete(true);
407     }
408   }
409
410   public void parseResult()
411   {
412     int results = 0; // number of result sets received
413     JobStateSummary finalState = new JobStateSummary();
414     try
415     {
416       for (int j = 0; j < jobs.length; j++)
417       {
418         finalState.updateJobPanelState(wsInfo, OutputHeader, jobs[j]);
419         if (jobs[j].isSubmitted() && jobs[j].isSubjobComplete()
420                 && jobs[j].hasResults())
421         {
422           results++;
423         }
424       }
425     } catch (Exception ex)
426     {
427
428       Cache.log.error("Unexpected exception when processing results for "
429               + altitle, ex);
430       wsInfo.setStatus(WebserviceInfo.STATE_STOPPED_ERROR);
431     }
432     if (results > 0)
433     {
434       wsInfo.showResultsNewFrame
435               .addActionListener(new java.awt.event.ActionListener()
436               {
437                 public void actionPerformed(java.awt.event.ActionEvent evt)
438                 {
439                   displayResults(true);
440                 }
441               });
442       wsInfo.mergeResults
443               .addActionListener(new java.awt.event.ActionListener()
444               {
445                 public void actionPerformed(java.awt.event.ActionEvent evt)
446                 {
447                   displayResults(false);
448                 }
449               });
450       wsInfo.setResultsReady();
451     }
452     else
453     {
454       wsInfo.setFinishedNoResults();
455     }
456   }
457
458   void displayResults(boolean newWindow)
459   {
460     // TODO: cope with multiple subjobs.
461     if (jobs != null)
462     {
463       Object[] res = null;
464       boolean msa = false;
465       for (int jn = 0; jn < jobs.length; jn++)
466       {
467         Object[] jobres = null;
468         JPredJob j = (JPredJob) jobs[jn];
469
470         if (j.hasResults())
471         {
472           // hack - we only deal with all single seuqence predictions or all
473           // profile predictions
474           msa = (j.msa != null) ? true : msa;
475           try
476           {
477             jalview.bin.Cache.log.debug("Parsing output of job " + jn);
478             jobres = j.getResultSet();
479             jalview.bin.Cache.log.debug("Finished parsing output.");
480             if (jobs.length == 1)
481             {
482               res = jobres;
483             }
484             else
485             {
486               // do merge with other job results
487               throw new Error(
488                       "Multiple JNet subjob merging not yet implemented.");
489             }
490           } catch (Exception e)
491           {
492             jalview.bin.Cache.log.error(
493                     "JNet Client: JPred Annotation Parse Error", e);
494             wsInfo.setStatus(j.getJobnum(),
495                     WebserviceInfo.STATE_STOPPED_ERROR);
496             wsInfo.appendProgressText(j.getJobnum(), OutputHeader + "\n"
497                     + j.result.getStatus()
498                     + "\nInvalid JNet job result data!\n" + e.getMessage());
499             j.result.setBroken(true);
500           }
501         }
502       }
503
504       if (res != null)
505       {
506         if (newWindow)
507         {
508           AlignFrame af;
509           if (input == null)
510           {
511             if (res[1] != null)
512             {
513               af = new AlignFrame((Alignment) res[0],
514                       (ColumnSelection) res[1], AlignFrame.DEFAULT_WIDTH,
515                       AlignFrame.DEFAULT_HEIGHT);
516             }
517             else
518             {
519               af = new AlignFrame((Alignment) res[0],
520                       AlignFrame.DEFAULT_WIDTH, AlignFrame.DEFAULT_HEIGHT);
521             }
522           }
523           else
524           {
525             /*
526              * java.lang.Object[] alandcolsel =
527              * input.getAlignmentAndColumnSelection
528              * (alignFrame.getViewport().getGapCharacter()); if
529              * (((SequenceI[])alandcolsel[0])[0].getLength()!=res.getWidth()) {
530              * if (msa) { throw new Error("Implementation Error! ColumnSelection
531              * from input alignment will not map to result alignment!"); } } if
532              * (!msa) { // update hidden regions to account for loss of gaps in
533              * profile. - if any // gapMap returns insert list, interpreted as
534              * delete list by pruneDeletions //((ColumnSelection)
535              * alandcolsel[1]).pruneDeletions(ShiftList.parseMap(((SequenceI[])
536              * alandcolsel[0])[0].gapMap())); }
537              */
538
539             af = new AlignFrame((Alignment) res[0],
540                     (ColumnSelection) res[1], AlignFrame.DEFAULT_WIDTH,
541                     AlignFrame.DEFAULT_HEIGHT);
542           }
543           Desktop.addInternalFrame(af, altitle, AlignFrame.DEFAULT_WIDTH,
544                   AlignFrame.DEFAULT_HEIGHT);
545         }
546         else
547         {
548           Cache.log.info("Append results onto existing alignment.");
549         }
550       }
551     }
552   }
553
554   public void pollJob(AWsJob job) throws Exception
555   {
556     ((JPredJob) job).result = server.getresult(job.getJobId());
557   }
558
559   public boolean isCancellable()
560   {
561     return false;
562   }
563
564   public void cancelJob()
565   {
566     throw new Error("Implementation error!");
567   }
568
569   public boolean canMergeResults()
570   {
571     return false;
572   }
573
574 }