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
 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             rpos = stats.getNextPosition();
 220           }
 221         } while (stats != null && rpos > cpos);
 222
 223         if (!finished && status.equals(JobStatus.FAILED))
 224         {
 225           try
 226           {
 227             Thread.sleep(200);
 228           } catch (InterruptedException x)
 229           {
 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:");
 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     }
 289
 290   }
 291
 292   @Override
 293   public void updateAnnotation()
 294   {
 295     updateResultAnnotation(false);
 296   }
 297
 298   public abstract void updateResultAnnotation(boolean immediate);
 299
 300   public abstract String getServiceActionText();
 301
 302   boolean submitGaps = true;
 303
 304   boolean alignedSeqs = true;
 305
 306   boolean nucleotidesAllowed = false;
 307
 308   boolean proteinAllowed = false;
 309
 310   /**
 311    * record sequences for mapping result back to afterwards
 312    */
 313   protected boolean bySequence = false;
 314
 315   Map<String, SequenceI> seqNames;
 316   boolean[] gapMap;
 317   int realw;
 318   public List<FastaSequence> getInputSequences(AlignmentI alignment)
 319   {
 320     if (alignment == null || alignment.getWidth() <= 0
 321             || alignment.getSequences() == null
 322             // || (alignedSeqs && !alignment.isAligned() && !submitGaps)
 323             || alignment.isNucleotide() ? !nucleotidesAllowed
 324             : !proteinAllowed)
 325     {
 326       return null;
 327     }
 328     List<compbio.data.sequence.FastaSequence> seqs = new ArrayList<compbio.data.sequence.FastaSequence>();
 329
 330     int minlen = 10;
 331     int ln = -1;
 332     if (bySequence)
 333     {
 334       seqNames = new HashMap<String, SequenceI>();
 335     }
 336     gapMap=new boolean[0];
 337     for (SequenceI sq : ((List<SequenceI>) alignment.getSequences()))
 338     {
 339       if (sq.getEnd() - sq.getStart() > minlen - 1)
 340       {
 341         String newname = SeqsetUtils.unique_name(seqs.size() + 1);
 342         // make new input sequence with or without gaps
 343         if (seqNames != null)
 344         {
 345           seqNames.put(newname, sq);
 346         }
 347         FastaSequence seq;
 348         if (submitGaps)
 349         {
 350           seqs.add(seq = new compbio.data.sequence.FastaSequence(newname,sq.getSequenceAsString()));
 351           if (gapMap==null || gapMap.length<seq.getSequence().length())
 352           {
 353             boolean[] tg=gapMap;
 354             gapMap=new boolean[seq.getLength()];
 355             System.arraycopy(tg, 0, gapMap, 0, tg.length);
 356             for (int p=tg.length;p<gapMap.length;p++)
 357             {
 358               gapMap[p]=false; // init as a gap
 359             }
 360           }
 361           for (int apos:sq.gapMap()) {
 362             gapMap[apos]=true; // aligned.
 363           }
 364         } else {
 365         seqs.add(seq = new compbio.data.sequence.FastaSequence(newname,
 366                 AlignSeq
 367                         .extractGaps(jalview.util.Comparison.GapChars,
 368                                 sq.getSequenceAsString())));
 369         }
 370         if (seq.getSequence().length() > ln)
 371         {
 372           ln = seq.getSequence().length();
 373         }
 374       }
 375     }
 376     if (alignedSeqs && submitGaps)
 377     {
 378       realw = 0;
 379       for (int i=0;i<gapMap.length;i++)
 380       {
 381         if (gapMap[i])
 382         {
 383           realw++;
 384         }
 385       }
 386       // try real hard to return something submittable
 387       // TODO: some of AAcons measures need a minimum of two or three amino
 388       // acids at each position, and aacons doesn't gracefully degrade.
 389       for (int p = 0; p < seqs.size(); p++)
 390       {
 391         FastaSequence sq = seqs.get(p);
 392         int l = sq.getSequence().length();
 393         // strip gapped columns
 394         char[] padded = new char[realw],orig=sq.getSequence().toCharArray();
 395         for (int i=0,pp=0;i<realw; pp++)
 396         {
 397           if (gapMap[pp])
 398           {
 399             if (orig.length>pp)
 400             {
 401               padded[i++]=orig[pp];
 402             } else {
 403               padded[i++]='-';
 404             }
 405           }
 406         }
 407         seqs.set(p, new compbio.data.sequence.FastaSequence(sq.getId(),
 408                   new String(padded)));
 409       }
 410     }
 411     return seqs;
 412   }
 413
 414   /**
 415    * notify manager that we have started, and wait for a free calculation slot
 416    *
 417    * @return true if slot is obtained and work still valid, false if another
 418    *         thread has done our work for us.
 419    */
 420   boolean checkDone()
 421   {
 422     calcMan.notifyStart(this);
 423     ap.paintAlignment(false);
 424     while (!calcMan.notifyWorking(this))
 425     {
 426       if (calcMan.isWorking(this))
 427       {
 428         return true;
 429       }
 430       try
 431       {
 432         if (ap != null)
 433         {
 434           ap.paintAlignment(false);
 435         }
 436
 437         Thread.sleep(200);
 438       } catch (Exception ex)
 439       {
 440         ex.printStackTrace();
 441       }
 442     }
 443     if (alignViewport.isClosed())
 444     {
 445       abortAndDestroy();
 446       return true;
 447     }
 448     return false;
 449   }
 450
 451 }