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