src/jalview/ws/jws2/AbstractJabaCalcWorker.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.jws2;
  22
  23 import jalview.analysis.AlignSeq;
  24 import jalview.analysis.SeqsetUtils;
  25 import jalview.api.AlignViewportI;
  26 import jalview.api.AlignmentViewPanel;
  27 import jalview.bin.Cache;
  28 import jalview.datamodel.AlignmentAnnotation;
  29 import jalview.datamodel.AlignmentI;
  30 import jalview.datamodel.AnnotatedCollectionI;
  31 import jalview.datamodel.SequenceI;
  32 import jalview.gui.AlignFrame;
  33 import jalview.gui.IProgressIndicator;
  34 import jalview.gui.IProgressIndicatorHandler;
  35 import jalview.schemes.ResidueProperties;
  36 import jalview.workers.AlignCalcWorker;
  37 import jalview.ws.jws2.dm.AAConSettings;
  38 import jalview.ws.jws2.dm.JabaWsParamSet;
  39 import jalview.ws.jws2.jabaws2.Jws2Instance;
  40 import jalview.ws.params.WsParamSetI;
  41
  42 import java.util.ArrayList;
  43 import java.util.HashMap;
  44 import java.util.List;
  45 import java.util.Map;
  46
  47 import compbio.data.sequence.FastaSequence;
  48 import compbio.metadata.Argument;
  49 import compbio.metadata.ChunkHolder;
  50 import compbio.metadata.JobStatus;
  51 import compbio.metadata.JobSubmissionException;
  52 import compbio.metadata.Option;
  53 import compbio.metadata.ResultNotAvailableException;
  54
  55 public abstract class AbstractJabaCalcWorker extends AlignCalcWorker
  56 {
  57
  58   protected Jws2Instance service;
  59
  60   protected WsParamSetI preset;
  61
  62   protected List<Argument> arguments;
  63
  64   protected IProgressIndicator guiProgress;
  65
  66   protected boolean submitGaps = true;
  67
  68   /**
  69    * by default, we filter out non-standard residues before submission
  70    */
  71   protected boolean filterNonStandardResidues = true;
  72
  73   /**
  74    * Recover any existing parameters for this service
  75    */
  76   protected void initViewportParams()
  77   {
  78     if (getCalcId() != null)
  79     {
  80       ((jalview.gui.AlignViewport) alignViewport).setCalcIdSettingsFor(
  81               getCalcId(),
  82               new AAConSettings(true, service, this.preset,
  83                       (arguments != null)
  84                               ? JabaParamStore.getJwsArgsfromJaba(arguments)
  85                               : null),
  86               true);
  87     }
  88   }
  89
  90   /**
  91    *
  92    * @return null or a string used to recover all annotation generated by this
  93    *         worker
  94    */
  95   public abstract String getCalcId();
  96
  97   public WsParamSetI getPreset()
  98   {
  99     return preset;
 100   }
 101
 102   public List<Argument> getArguments()
 103   {
 104     return arguments;
 105   }
 106
 107   /**
 108    * reconfigure and restart the AAConClient. This method will spawn a new
 109    * thread that will wait until any current jobs are finished, modify the
 110    * parameters and restart the conservation calculation with the new values.
 111    *
 112    * @param newpreset
 113    * @param newarguments
 114    */
 115   public void updateParameters(final WsParamSetI newpreset,
 116           final List<Argument> newarguments)
 117   {
 118     preset = newpreset;
 119     arguments = newarguments;
 120     calcMan.startWorker(this);
 121     initViewportParams();
 122   }
 123
 124   public List<Option> getJabaArguments()
 125   {
 126     List<Option> newargs = new ArrayList<>();
 127     if (preset != null && preset instanceof JabaWsParamSet)
 128     {
 129       newargs.addAll(((JabaWsParamSet) preset).getjabaArguments());
 130     }
 131     if (arguments != null && arguments.size() > 0)
 132     {
 133       for (Argument rg : arguments)
 134       {
 135         if (Option.class.isAssignableFrom(rg.getClass()))
 136         {
 137           newargs.add((Option) rg);
 138         }
 139       }
 140     }
 141     return newargs;
 142   }
 143
 144   protected boolean alignedSeqs = true;
 145
 146   protected boolean nucleotidesAllowed = false;
 147
 148   protected boolean proteinAllowed = false;
 149
 150   /**
 151    * record sequences for mapping result back to afterwards
 152    */
 153   protected boolean bySequence = false;
 154
 155   protected Map<String, SequenceI> seqNames;
 156
 157   protected boolean[] gapMap;
 158
 159   int realw;
 160
 161   protected int start;
 162
 163   int end;
 164
 165   public AbstractJabaCalcWorker(AlignViewportI alignViewport,
 166           AlignmentViewPanel alignPanel)
 167   {
 168     super(alignViewport, alignPanel);
 169   }
 170
 171   public AbstractJabaCalcWorker(Jws2Instance service, AlignFrame alignFrame,
 172           WsParamSetI preset, List<Argument> paramset)
 173   {
 174     this(alignFrame.getCurrentView(), alignFrame.alignPanel);
 175     this.guiProgress = alignFrame;
 176     this.preset = preset;
 177     this.arguments = paramset;
 178     this.service = service;
 179   }
 180
 181   /**
 182    *
 183    * @return true if the submission thread should attempt to submit data
 184    */
 185   abstract boolean hasService();
 186
 187   volatile String rslt = "JOB NOT DEFINED";
 188
 189   @Override
 190   public void run()
 191   {
 192     if (!hasService())
 193     {
 194       return;
 195     }
 196     long progressId = -1;
 197
 198     int serverErrorsLeft = 3;
 199
 200     StringBuffer msg = new StringBuffer();
 201     try
 202     {
 203       if (checkDone())
 204       {
 205         return;
 206       }
 207       List<compbio.data.sequence.FastaSequence> seqs = getInputSequences(
 208               alignViewport.getAlignment(),
 209               bySequence ? alignViewport.getSelectionGroup() : null);
 210
 211       if (seqs == null || !checkValidInputSeqs(true, seqs))
 212       {
 213         calcMan.workerComplete(this);
 214         return;
 215       }
 216
 217       AlignmentAnnotation[] aa = alignViewport.getAlignment()
 218               .getAlignmentAnnotation();
 219       if (guiProgress != null)
 220       {
 221         guiProgress.setProgressBar("JABA " + getServiceActionText(),
 222                 progressId = System.currentTimeMillis());
 223       }
 224       rslt = submitToService(seqs);
 225       if (guiProgress != null)
 226       {
 227         guiProgress.registerHandler(progressId,
 228                 new IProgressIndicatorHandler()
 229                 {
 230
 231                   @Override
 232                   public boolean cancelActivity(long id)
 233                   {
 234                     cancelCurrentJob();
 235                     return true;
 236                   }
 237
 238                   @Override
 239                   public boolean canCancel()
 240                   {
 241                     return true;
 242                   }
 243                 });
 244       }
 245       boolean finished = false;
 246       long rpos = 0;
 247       do
 248       {
 249         JobStatus status = getJobStatus(rslt);
 250         if (status.equals(JobStatus.FINISHED))
 251         {
 252           finished = true;
 253         }
 254         if (calcMan.isPending(this) && isInteractiveUpdate())
 255         {
 256           finished = true;
 257           // cancel this job and yield to the new job
 258           try
 259           {
 260             if (cancelJob(rslt))
 261             {
 262               System.err.println("Cancelled AACon job: " + rslt);
 263             }
 264             else
 265             {
 266               System.err.println("FAILED TO CANCEL AACon job: " + rslt);
 267             }
 268
 269           } catch (Exception x)
 270           {
 271
 272           }
 273           rslt = "CANCELLED JOB";
 274           return;
 275         }
 276         long cpos;
 277         ChunkHolder stats = null;
 278         do
 279         {
 280           cpos = rpos;
 281           boolean retry = false;
 282           do
 283           {
 284             try
 285             {
 286               stats = pullExecStatistics(rslt, rpos);
 287             } catch (Exception x)
 288             {
 289
 290               if (x.getMessage().contains(
 291                       "Position in a file could not be negative!"))
 292               {
 293                 // squash index out of bounds exception- seems to happen for
 294                 // disorder predictors which don't (apparently) produce any
 295                 // progress information and JABA server throws an exception
 296                 // because progress length is -1.
 297                 stats = null;
 298               }
 299               else
 300               {
 301                 if (--serverErrorsLeft > 0)
 302                 {
 303                   retry = true;
 304                   try
 305                   {
 306                     Thread.sleep(200);
 307                   } catch (InterruptedException q)
 308                   {
 309                   }
 310                   ;
 311                 }
 312                 else
 313                 {
 314                   throw x;
 315                 }
 316               }
 317             }
 318           } while (retry);
 319           if (stats != null)
 320           {
 321             System.out.print(stats.getChunk());
 322             msg.append(stats);
 323             rpos = stats.getNextPosition();
 324           }
 325         } while (stats != null && rpos > cpos);
 326
 327         if (!finished && status.equals(JobStatus.FAILED))
 328         {
 329           try
 330           {
 331             Thread.sleep(200);
 332           } catch (InterruptedException x)
 333           {
 334           }
 335           ;
 336         }
 337       } while (!finished);
 338       if (serverErrorsLeft > 0)
 339       {
 340         try
 341         {
 342           Thread.sleep(200);
 343         } catch (InterruptedException x)
 344         {
 345         }
 346         if (collectAnnotationResultsFor(rslt))
 347         {
 348           Cache.debug("Updating result annotation from Job "
 349                   + rslt + " at " + service.getUri());
 350           updateResultAnnotation(true);
 351           ap.adjustAnnotationHeight();
 352         }
 353       }
 354     }
 355
 356     catch (JobSubmissionException x)
 357     {
 358
 359       System.err.println(
 360               "submission error with " + getServiceActionText() + " :");
 361       x.printStackTrace();
 362       calcMan.disableWorker(this);
 363     } catch (ResultNotAvailableException x)
 364     {
 365       System.err.println("collection error:\nJob ID: " + rslt);
 366       x.printStackTrace();
 367       calcMan.disableWorker(this);
 368
 369     } catch (OutOfMemoryError error)
 370     {
 371       calcMan.disableWorker(this);
 372
 373       // consensus = null;
 374       // hconsensus = null;
 375       ap.raiseOOMWarning(getServiceActionText(), error);
 376     } catch (Exception x)
 377     {
 378       calcMan.disableWorker(this);
 379
 380       // consensus = null;
 381       // hconsensus = null;
 382       System.err
 383               .println("Blacklisting worker due to unexpected exception:");
 384       x.printStackTrace();
 385     } finally
 386     {
 387
 388       calcMan.workerComplete(this);
 389       if (ap != null)
 390       {
 391         calcMan.workerComplete(this);
 392         if (guiProgress != null && progressId != -1)
 393         {
 394           guiProgress.setProgressBar("", progressId);
 395         }
 396         // TODO: may not need to paintAlignment again !
 397         ap.paintAlignment(false, false);
 398       }
 399       if (msg.length() > 0)
 400       {
 401         // TODO: stash message somewhere in annotation or alignment view.
 402         // code below shows result in a text box popup
 403         /*
 404          * jalview.gui.CutAndPasteTransfer cap = new
 405          * jalview.gui.CutAndPasteTransfer(); cap.setText(msg.toString());
 406          * jalview.gui.Desktop.addInternalFrame(cap,
 407          * "Job Status for "+getServiceActionText(), 600, 400);
 408          */
 409       }
 410     }
 411
 412   }
 413
 414   /**
 415    * validate input for dynamic/non-dynamic update context
 416    *
 417    * @param dynamic
 418    * @param seqs
 419    * @return true if input is valid
 420    */
 421   abstract boolean checkValidInputSeqs(boolean dynamic,
 422           List<FastaSequence> seqs);
 423
 424   abstract String submitToService(
 425           List<compbio.data.sequence.FastaSequence> seqs)
 426           throws JobSubmissionException;
 427
 428   abstract boolean cancelJob(String rslt) throws Exception;
 429
 430   abstract JobStatus getJobStatus(String rslt) throws Exception;
 431
 432   abstract ChunkHolder pullExecStatistics(String rslt, long rpos);
 433
 434   abstract boolean collectAnnotationResultsFor(String rslt)
 435           throws ResultNotAvailableException;
 436
 437   public void cancelCurrentJob()
 438   {
 439     try
 440     {
 441       String id = rslt;
 442       if (cancelJob(rslt))
 443       {
 444         System.err.println("Cancelled job " + id);
 445       }
 446       else
 447       {
 448         System.err.println("Job " + id + " couldn't be cancelled.");
 449       }
 450     } catch (Exception q)
 451     {
 452       q.printStackTrace();
 453     }
 454   }
 455
 456   /**
 457    * Interactive updating. Analysis calculations that work on the currently
 458    * displayed alignment data should cancel existing jobs when the input data
 459    * has changed.
 460    *
 461    * @return true if a running job should be cancelled because new input data is
 462    *         available for analysis
 463    */
 464   abstract boolean isInteractiveUpdate();
 465
 466   public List<FastaSequence> getInputSequences(AlignmentI alignment,
 467           AnnotatedCollectionI inputSeqs)
 468   {
 469     if (alignment == null || alignment.getWidth() <= 0
 470             || alignment.getSequences() == null || alignment.isNucleotide()
 471                     ? !nucleotidesAllowed
 472                     : !proteinAllowed)
 473     {
 474       return null;
 475     }
 476     if (inputSeqs == null || inputSeqs.getWidth() <= 0
 477             || inputSeqs.getSequences() == null
 478             || inputSeqs.getSequences().size() < 1)
 479     {
 480       inputSeqs = alignment;
 481     }
 482
 483     List<compbio.data.sequence.FastaSequence> seqs = new ArrayList<>();
 484
 485     int minlen = 10;
 486     int ln = -1;
 487     if (bySequence)
 488     {
 489       seqNames = new HashMap<>();
 490     }
 491     gapMap = new boolean[0];
 492     start = inputSeqs.getStartRes();
 493     end = inputSeqs.getEndRes();
 494
 495     for (SequenceI sq : (inputSeqs.getSequences()))
 496     {
 497       if (bySequence
 498               ? sq.findPosition(end + 1)
 499                       - sq.findPosition(start + 1) > minlen - 1
 500               : sq.getEnd() - sq.getStart() > minlen - 1)
 501       {
 502         String newname = SeqsetUtils.unique_name(seqs.size() + 1);
 503         // make new input sequence with or without gaps
 504         if (seqNames != null)
 505         {
 506           seqNames.put(newname, sq);
 507         }
 508         FastaSequence seq;
 509         if (submitGaps)
 510         {
 511           seqs.add(seq = new compbio.data.sequence.FastaSequence(newname,
 512                   sq.getSequenceAsString()));
 513           if (gapMap == null || gapMap.length < seq.getSequence().length())
 514           {
 515             boolean[] tg = gapMap;
 516             gapMap = new boolean[seq.getLength()];
 517             System.arraycopy(tg, 0, gapMap, 0, tg.length);
 518             for (int p = tg.length; p < gapMap.length; p++)
 519             {
 520               gapMap[p] = false; // init as a gap
 521             }
 522           }
 523           for (int apos : sq.gapMap())
 524           {
 525             char sqc = sq.getCharAt(apos);
 526             if (!filterNonStandardResidues
 527                     || (sq.isProtein() ? ResidueProperties.aaIndex[sqc] < 20
 528                             : ResidueProperties.nucleotideIndex[sqc] < 5))
 529             {
 530               gapMap[apos] = true; // aligned and real amino acid residue
 531             }
 532             ;
 533           }
 534         }
 535         else
 536         {
 537           seqs.add(seq = new compbio.data.sequence.FastaSequence(newname,
 538                   AlignSeq.extractGaps(jalview.util.Comparison.GapChars,
 539                           sq.getSequenceAsString(start, end + 1))));
 540         }
 541         if (seq.getSequence().length() > ln)
 542         {
 543           ln = seq.getSequence().length();
 544         }
 545       }
 546     }
 547     if (alignedSeqs && submitGaps)
 548     {
 549       realw = 0;
 550       for (int i = 0; i < gapMap.length; i++)
 551       {
 552         if (gapMap[i])
 553         {
 554           realw++;
 555         }
 556       }
 557       // try real hard to return something submittable
 558       // TODO: some of AAcon measures need a minimum of two or three amino
 559       // acids at each position, and AAcon doesn't gracefully degrade.
 560       for (int p = 0; p < seqs.size(); p++)
 561       {
 562         FastaSequence sq = seqs.get(p);
 563         int l = sq.getSequence().length();
 564         // strip gapped columns
 565         char[] padded = new char[realw],
 566                 orig = sq.getSequence().toCharArray();
 567         for (int i = 0, pp = 0; i < realw; pp++)
 568         {
 569           if (gapMap[pp])
 570           {
 571             if (orig.length > pp)
 572             {
 573               padded[i++] = orig[pp];
 574             }
 575             else
 576             {
 577               padded[i++] = '-';
 578             }
 579           }
 580         }
 581         seqs.set(p, new compbio.data.sequence.FastaSequence(sq.getId(),
 582                 new String(padded)));
 583       }
 584     }
 585     return seqs;
 586   }
 587
 588   @Override
 589   public void updateAnnotation()
 590   {
 591     updateResultAnnotation(false);
 592   }
 593
 594   public abstract void updateResultAnnotation(boolean immediate);
 595
 596   public abstract String getServiceActionText();
 597
 598   /**
 599    * notify manager that we have started, and wait for a free calculation slot
 600    *
 601    * @return true if slot is obtained and work still valid, false if another
 602    *         thread has done our work for us.
 603    */
 604   protected boolean checkDone()
 605   {
 606     calcMan.notifyStart(this);
 607     ap.paintAlignment(false, false);
 608     while (!calcMan.notifyWorking(this))
 609     {
 610       if (calcMan.isWorking(this))
 611       {
 612         return true;
 613       }
 614       try
 615       {
 616         if (ap != null)
 617         {
 618           ap.paintAlignment(false, false);
 619         }
 620
 621         Thread.sleep(200);
 622       } catch (Exception ex)
 623       {
 624         ex.printStackTrace();
 625       }
 626     }
 627     if (alignViewport.isClosed())
 628     {
 629       abortAndDestroy();
 630       return true;
 631     }
 632     return false;
 633   }
 634
 635   protected void updateOurAnnots(List<AlignmentAnnotation> ourAnnot)
 636   {
 637     List<AlignmentAnnotation> our = ourAnnots;
 638     ourAnnots = ourAnnot;
 639     AlignmentI alignment = alignViewport.getAlignment();
 640     if (our != null)
 641     {
 642       if (our.size() > 0)
 643       {
 644         for (AlignmentAnnotation an : our)
 645         {
 646           if (!ourAnnots.contains(an))
 647           {
 648             // remove the old annotation
 649             alignment.deleteAnnotation(an);
 650           }
 651         }
 652       }
 653       our.clear();
 654
 655       ap.adjustAnnotationHeight();
 656     }
 657   }
 658
 659 }