src/jalview/ws/jws2/JabawsAlignCalcWorker.java

   1 package jalview.ws.jws2;
   2
   3 import jalview.analysis.AlignSeq;
   4 import jalview.analysis.SeqsetUtils;
   5 import jalview.api.AlignViewportI;
   6 import jalview.api.AlignmentViewPanel;
   7 import jalview.datamodel.AlignmentAnnotation;
   8 import jalview.datamodel.AlignmentI;
   9 import jalview.datamodel.SequenceI;
  10 import jalview.gui.AlignFrame;
  11 import jalview.gui.IProgressIndicator;
  12 import jalview.workers.AlignCalcWorker;
  13 import jalview.ws.jws2.dm.JabaWsParamSet;
  14 import jalview.ws.jws2.jabaws2.Jws2Instance;
  15 import jalview.ws.params.WsParamSetI;
  16
  17 import java.util.ArrayList;
  18 import java.util.HashMap;
  19 import java.util.List;
  20 import java.util.Map;
  21
  22 import compbio.data.msa.SequenceAnnotation;
  23 import compbio.data.sequence.FastaSequence;
  24 import compbio.data.sequence.ScoreManager;
  25 import compbio.metadata.Argument;
  26 import compbio.metadata.ChunkHolder;
  27 import compbio.metadata.JobStatus;
  28 import compbio.metadata.JobSubmissionException;
  29 import compbio.metadata.Option;
  30 import compbio.metadata.ResultNotAvailableException;
  31 import compbio.metadata.WrongParameterException;
  32
  33 public abstract class JabawsAlignCalcWorker extends AlignCalcWorker
  34 {
  35   Jws2Instance service;
  36   @SuppressWarnings("unchecked")
  37   protected SequenceAnnotation aaservice;
  38
  39   protected ScoreManager scoremanager;
  40
  41   protected WsParamSetI preset;
  42
  43   protected List<Argument> arguments;
  44
  45   public JabawsAlignCalcWorker(AlignViewportI alignViewport,
  46           AlignmentViewPanel alignPanel)
  47   {
  48     super(alignViewport, alignPanel);
  49   }
  50
  51   IProgressIndicator guiProgress;
  52
  53   public JabawsAlignCalcWorker(Jws2Instance service, AlignFrame alignFrame,
  54           WsParamSetI preset, List<Argument> paramset)
  55   {
  56     this(alignFrame.getCurrentView(), alignFrame.alignPanel);
  57     this.guiProgress = alignFrame;
  58     this.preset = preset;
  59     this.arguments = paramset;
  60     this.service = service;
  61     aaservice = (SequenceAnnotation) service.service;
  62
  63   }
  64
  65   public WsParamSetI getPreset()
  66   {
  67     return preset;
  68   }
  69
  70   public List<Argument> getArguments()
  71   {
  72     return arguments;
  73   }
  74
  75   /**
  76    * reconfigure and restart the AAConsClient. This method will spawn a new
  77    * thread that will wait until any current jobs are finished, modify the
  78    * parameters and restart the conservation calculation with the new values.
  79    *
  80    * @param newpreset
  81    * @param newarguments
  82    */
  83   public void updateParameters(final WsParamSetI newpreset,
  84           final List<Argument> newarguments)
  85   {
  86     preset = newpreset;
  87     arguments = newarguments;
  88     calcMan.startWorker(this);
  89   }
  90
  91   public List<Option> getJabaArguments()
  92   {
  93     List<Option> newargs = new ArrayList<Option>();
  94     if (preset != null && preset instanceof JabaWsParamSet)
  95     {
  96       newargs.addAll(((JabaWsParamSet) preset).getjabaArguments());
  97     }
  98     if (arguments != null && arguments.size() > 0)
  99     {
 100       for (Argument rg : arguments)
 101       {
 102         if (Option.class.isAssignableFrom(rg.getClass()))
 103         {
 104           newargs.add((Option) rg);
 105         }
 106       }
 107     }
 108     return newargs;
 109   }
 110
 111   @Override
 112   public void run()
 113   {
 114     if (aaservice == null)
 115     {
 116       return;
 117     }
 118     long progressId = -1;
 119
 120     String rslt = "JOB NOT DEFINED";
 121     StringBuffer msg=new StringBuffer();
 122     try
 123     {
 124       if (checkDone())
 125       {
 126         return;
 127       }
 128       List<compbio.data.sequence.FastaSequence> seqs = getInputSequences(alignViewport
 129               .getAlignment());
 130
 131       if (seqs == null)
 132       {
 133         calcMan.workerComplete(this);
 134         return;
 135       }
 136
 137       AlignmentAnnotation[] aa = alignViewport.getAlignment()
 138               .getAlignmentAnnotation();
 139       if (guiProgress != null)
 140       {
 141         guiProgress.setProgressBar("JABA " + getServiceActionText(),
 142                 progressId = System.currentTimeMillis());
 143       }
 144       if (preset == null && arguments==null)
 145       {
 146         rslt = aaservice.analize(seqs);
 147       }
 148       else
 149       {
 150         try
 151         {
 152           rslt = aaservice.customAnalize(seqs, getJabaArguments());
 153         } catch (WrongParameterException x)
 154         {
 155           throw new JobSubmissionException(
 156                   "Invalid paremeter set. Check Jalview implementation.", x);
 157
 158         }
 159       }
 160       boolean finished = false;
 161       long rpos = 0;
 162       do
 163       {
 164         JobStatus status = aaservice.getJobStatus(rslt);
 165         if (status.equals(JobStatus.FINISHED))
 166         {
 167           finished = true;
 168         }
 169         if (calcMan.isPending(this) && this instanceof AAConsClient)
 170         {
 171           finished = true;
 172           // cancel this job and yield to the new job
 173           try
 174           {
 175             if (aaservice.cancelJob(rslt))
 176             {
 177               System.err.println("Cancelled AACon job: " + rslt);
 178             }
 179             else
 180             {
 181               System.err.println("FAILED TO CANCELL AACon job: " + rslt);
 182             }
 183
 184           } catch (Exception x)
 185           {
 186
 187           }
 188
 189           return;
 190         }
 191         long cpos;
 192         ChunkHolder stats;
 193         do
 194         {
 195           cpos = rpos;
 196           try
 197           {
 198             stats = aaservice.pullExecStatistics(rslt, rpos);
 199           } catch (Exception x)
 200           {
 201
 202             if (x.getMessage().contains(
 203                     "Position in a file could not be negative!"))
 204             {
 205               // squash index out of bounds exception- seems to happen for
 206               // disorder predictors which don't (apparently) produce any
 207               // progress information and JABA server throws an exception
 208               // because progress length is -1.
 209               stats = null;
 210             }
 211             else
 212             {
 213               throw x;
 214             }
 215           }
 216           if (stats != null)
 217           {
 218             System.out.print(stats.getChunk());
 219             msg.append(stats);
 220             rpos = stats.getNextPosition();
 221           }
 222         } while (stats != null && rpos > cpos);
 223
 224         if (!finished && status.equals(JobStatus.FAILED))
 225         {
 226           try
 227           {
 228             Thread.sleep(200);
 229           } catch (InterruptedException x)
 230           {
 231           }
 232           ;
 233         }
 234       } while (!finished);
 235       try
 236       {
 237         Thread.sleep(200);
 238       } catch (InterruptedException x)
 239       {
 240       }
 241       ;
 242       scoremanager = aaservice.getAnnotation(rslt);
 243       if (scoremanager != null)
 244       {
 245         updateResultAnnotation(true);
 246       }
 247     } catch (JobSubmissionException x)
 248     {
 249
 250       System.err.println("submission error with "+getServiceActionText()+" :");
 251       x.printStackTrace();
 252       calcMan.workerCannotRun(this);
 253     } catch (ResultNotAvailableException x)
 254     {
 255       System.err.println("collection error:\nJob ID: " + rslt);
 256       x.printStackTrace();
 257       calcMan.workerCannotRun(this);
 258
 259     } catch (OutOfMemoryError error)
 260     {
 261       calcMan.workerCannotRun(this);
 262
 263       // consensus = null;
 264       // hconsensus = null;
 265       ap.raiseOOMWarning(getServiceActionText(), error);
 266     } catch (Exception x)
 267     {
 268       calcMan.workerCannotRun(this);
 269
 270       // consensus = null;
 271       // hconsensus = null;
 272       System.err
 273               .println("Blacklisting worker due to unexpected exception:");
 274       x.printStackTrace();
 275     } finally
 276     {
 277
 278       calcMan.workerComplete(this);
 279       if (ap != null)
 280       {
 281         calcMan.workerComplete(this);
 282         if (guiProgress != null && progressId!=-1)
 283         {
 284           guiProgress.setProgressBar("", progressId);
 285         }
 286         ap.paintAlignment(true);
 287       }
 288       if (msg.length()>0)
 289       {
 290         // TODO: stash message somewhere in annotation or alignment view.
 291         // code below shows result in a text box popup
 292         /* jalview.gui.CutAndPasteTransfer cap = new jalview.gui.CutAndPasteTransfer();
 293         cap.setText(msg.toString());
 294         jalview.gui.Desktop.addInternalFrame(cap, "Job Status for "+getServiceActionText(), 600, 400); */
 295       }
 296     }
 297
 298   }
 299
 300   @Override
 301   public void updateAnnotation()
 302   {
 303     updateResultAnnotation(false);
 304   }
 305
 306   public abstract void updateResultAnnotation(boolean immediate);
 307
 308   public abstract String getServiceActionText();
 309
 310   boolean submitGaps = true;
 311
 312   boolean alignedSeqs = true;
 313
 314   boolean nucleotidesAllowed = false;
 315
 316   boolean proteinAllowed = false;
 317
 318   /**
 319    * record sequences for mapping result back to afterwards
 320    */
 321   protected boolean bySequence = false;
 322
 323   Map<String, SequenceI> seqNames;
 324   boolean[] gapMap;
 325   int realw;
 326   public List<FastaSequence> getInputSequences(AlignmentI alignment)
 327   {
 328     if (alignment == null || alignment.getWidth() <= 0
 329             || alignment.getSequences() == null
 330             // || (alignedSeqs && !alignment.isAligned() && !submitGaps)
 331             || alignment.isNucleotide() ? !nucleotidesAllowed
 332             : !proteinAllowed)
 333     {
 334       return null;
 335     }
 336     List<compbio.data.sequence.FastaSequence> seqs = new ArrayList<compbio.data.sequence.FastaSequence>();
 337
 338     int minlen = 10;
 339     int ln = -1;
 340     if (bySequence)
 341     {
 342       seqNames = new HashMap<String, SequenceI>();
 343     }
 344     gapMap=new boolean[0];
 345     for (SequenceI sq : ((List<SequenceI>) alignment.getSequences()))
 346     {
 347       if (sq.getEnd() - sq.getStart() > minlen - 1)
 348       {
 349         String newname = SeqsetUtils.unique_name(seqs.size() + 1);
 350         // make new input sequence with or without gaps
 351         if (seqNames != null)
 352         {
 353           seqNames.put(newname, sq);
 354         }
 355         FastaSequence seq;
 356         if (submitGaps)
 357         {
 358           seqs.add(seq = new compbio.data.sequence.FastaSequence(newname,sq.getSequenceAsString()));
 359           if (gapMap==null || gapMap.length<seq.getSequence().length())
 360           {
 361             boolean[] tg=gapMap;
 362             gapMap=new boolean[seq.getLength()];
 363             System.arraycopy(tg, 0, gapMap, 0, tg.length);
 364             for (int p=tg.length;p<gapMap.length;p++)
 365             {
 366               gapMap[p]=false; // init as a gap
 367             }
 368           }
 369           for (int apos:sq.gapMap()) {
 370             gapMap[apos]=true; // aligned.
 371           }
 372         } else {
 373         seqs.add(seq = new compbio.data.sequence.FastaSequence(newname,
 374                 AlignSeq
 375                         .extractGaps(jalview.util.Comparison.GapChars,
 376                                 sq.getSequenceAsString())));
 377         }
 378         if (seq.getSequence().length() > ln)
 379         {
 380           ln = seq.getSequence().length();
 381         }
 382       }
 383     }
 384     if (alignedSeqs && submitGaps)
 385     {
 386       realw = 0;
 387       for (int i=0;i<gapMap.length;i++)
 388       {
 389         if (gapMap[i])
 390         {
 391           realw++;
 392         }
 393       }
 394       // try real hard to return something submittable
 395       // TODO: some of AAcons measures need a minimum of two or three amino
 396       // acids at each position, and aacons doesn't gracefully degrade.
 397       for (int p = 0; p < seqs.size(); p++)
 398       {
 399         FastaSequence sq = seqs.get(p);
 400         int l = sq.getSequence().length();
 401         // strip gapped columns
 402         char[] padded = new char[realw],orig=sq.getSequence().toCharArray();
 403         for (int i=0,pp=0;i<realw; pp++)
 404         {
 405           if (gapMap[pp])
 406           {
 407             if (orig.length>pp)
 408             {
 409               padded[i++]=orig[pp];
 410             } else {
 411               padded[i++]='-';
 412             }
 413           }
 414         }
 415         seqs.set(p, new compbio.data.sequence.FastaSequence(sq.getId(),
 416                   new String(padded)));
 417       }
 418     }
 419     return seqs;
 420   }
 421
 422   /**
 423    * notify manager that we have started, and wait for a free calculation slot
 424    *
 425    * @return true if slot is obtained and work still valid, false if another
 426    *         thread has done our work for us.
 427    */
 428   boolean checkDone()
 429   {
 430     calcMan.notifyStart(this);
 431     ap.paintAlignment(false);
 432     while (!calcMan.notifyWorking(this))
 433     {
 434       if (calcMan.isWorking(this))
 435       {
 436         return true;
 437       }
 438       try
 439       {
 440         if (ap != null)
 441         {
 442           ap.paintAlignment(false);
 443         }
 444
 445         Thread.sleep(200);
 446       } catch (Exception ex)
 447       {
 448         ex.printStackTrace();
 449       }
 450     }
 451     if (alignViewport.isClosed())
 452     {
 453       abortAndDestroy();
 454       return true;
 455     }
 456     return false;
 457   }
 458
 459 }