src/jalview/ws/jws2/JabaParamStore.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8)
   3  * Copyright (C) 2012 J Procter, AM Waterhouse, LM Lui, J Engelhardt, 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.jws2;
  19
  20 import java.io.IOException;
  21 import java.util.ArrayList;
  22 import java.util.Arrays;
  23 import java.util.Hashtable;
  24 import java.util.List;
  25 import java.util.StringTokenizer;
  26
  27 import org.jmol.util.ArrayUtil;
  28 import compbio.metadata.Argument;
  29 import compbio.metadata.Option;
  30 import compbio.metadata.Parameter;
  31 import compbio.metadata.Preset;
  32 import compbio.metadata.PresetManager;
  33 import compbio.metadata.RunnerConfig;
  34
  35 import jalview.ws.jws2.dm.JabaOption;
  36 import jalview.ws.jws2.dm.JabaParameter;
  37 import jalview.ws.jws2.dm.JabaWsParamSet;
  38 import jalview.ws.jws2.jabaws2.Jws2Instance;
  39 import jalview.ws.params.ArgumentI;
  40 import jalview.ws.params.ParamDatastoreI;
  41 import jalview.ws.params.ParamManager;
  42 import jalview.ws.params.WsParamSetI;
  43
  44 public class JabaParamStore implements ParamDatastoreI
  45 {
  46
  47   Hashtable<String, JabaWsParamSet> editedParams = new Hashtable<String, JabaWsParamSet>();
  48
  49   private Jws2Instance service;
  50
  51   private RunnerConfig serviceOptions;
  52
  53   private Hashtable<String, JabaPreset> servicePresets;
  54
  55   public JabaParamStore(Jws2Instance service)
  56   {
  57     this(service, null);
  58   }
  59
  60   ParamManager manager;
  61
  62   public JabaParamStore(Jws2Instance service, ParamManager manager)
  63   {
  64     this.service = service;
  65     serviceOptions = service.getRunnerConfig();
  66     this.manager = manager;
  67     // discover all the user's locally stored presets for this service and
  68     // populate the hash table
  69     if (manager != null)
  70     {
  71       manager.registerParser(service.getUri(), this);
  72       WsParamSetI[] prams = manager.getParameterSet(null, service.getUri(),
  73               true, false);
  74       if (prams != null)
  75       {
  76         for (WsParamSetI paramset : prams)
  77         {
  78           if (paramset instanceof JabaWsParamSet)
  79           {
  80             editedParams.put(paramset.getName(), (JabaWsParamSet) paramset);
  81           }
  82           else
  83           {
  84             System.err
  85                     .println("Warning: Ignoring parameter set instance of type "
  86                             + paramset.getClass()
  87                             + " : Bound but not applicable for service at "
  88                             + service.getUri());
  89           }
  90         }
  91       }
  92     }
  93   }
  94
  95   @Override
  96   public List<WsParamSetI> getPresets()
  97   {
  98     List<WsParamSetI> prefs = new ArrayList();
  99     if (servicePresets == null)
 100     {
 101       servicePresets = new Hashtable<String, JabaPreset>();
 102       PresetManager prman;
 103       if ((prman = service.getPresets()) != null)
 104       {
 105         List pset = prman.getPresets();
 106         if (pset != null)
 107         {
 108           for (Object pr : pset)
 109           {
 110             JabaPreset prset = new JabaPreset(service, (Preset) pr);
 111             servicePresets.put(prset.getName(), prset);
 112           }
 113         }
 114       }
 115     }
 116     for (JabaPreset pr : servicePresets.values())
 117     {
 118       prefs.add(pr);
 119     }
 120     for (WsParamSetI wspset : editedParams.values())
 121     {
 122       prefs.add(wspset);
 123     }
 124     return prefs;
 125   }
 126
 127   @Override
 128   public WsParamSetI getPreset(String name)
 129   {
 130     for (WsParamSetI pr : getPresets())
 131     {
 132       if (pr.getName().equals(name))
 133       {
 134         return pr;
 135       }
 136     }
 137     return null;
 138   }
 139
 140   public static List<ArgumentI> getJwsArgsfromJaba(List jabargs)
 141   {
 142     return getJwsArgsfromJaba(jabargs, true);
 143   }
 144
 145   public static List<ArgumentI> getJwsArgsfromJaba(List jabargs,
 146           boolean sortByOpt)
 147   {
 148     List<ArgumentI> rgs = new ArrayList<ArgumentI>();
 149     List<String> rgnames = new ArrayList<String>();
 150     for (Object rg : jabargs)
 151     {
 152       ArgumentI narg = null;
 153       String nargstring = null;
 154       if (rg instanceof Parameter)
 155       {
 156         narg = new JabaParameter((Parameter) rg);
 157         nargstring = narg.getName(); // just sort by name for this
 158       }
 159       else if (rg instanceof Option)
 160       {
 161         narg = new JabaOption((Option) rg);
 162         nargstring = (String) ((Option) rg).getOptionNames().get(0);
 163       }
 164       if (narg == null)
 165       {
 166         throw new Error(
 167                 "Implementation Error: Cannot handle Jaba parameter object "
 168                         + rg.getClass());
 169       }
 170       else
 171       {
 172         rgs.add(narg);
 173         rgnames.add(nargstring);
 174       }
 175     }
 176     if (!sortByOpt)
 177     {
 178       return rgs;
 179     }
 180     ArgumentI[] rgssort = rgs.toArray(new ArgumentI[rgs.size()]);
 181     String[] rgssorton = rgnames.toArray(new String[rgs.size()]);
 182     jalview.util.QuickSort.sort(rgssorton, rgssort);
 183     ArgumentI tmp1;
 184     int i=0;
 185     while (rgssort.length-i>i)
 186     {
 187       tmp1=rgssort[rgssort.length-i-1];
 188       rgssort[rgssort.length-i-1] = rgssort[i];
 189       rgssort[i++]=tmp1;
 190     }
 191     return Arrays.asList(rgssort);
 192   }
 193
 194   public static List getJabafromJwsArgs(List<ArgumentI> jwsargs)
 195   {
 196     List rgs = new ArrayList();
 197     for (ArgumentI rg : jwsargs)
 198     {
 199       Argument narg = (rg instanceof JabaOption) ? ((JabaOption) rg)
 200               .getOption() : null;
 201       if (narg == null)
 202       {
 203         throw new Error(
 204                 "Implementation Error: Cannot handle Jaba parameter object "
 205                         + rg.getClass());
 206       }
 207       else
 208       {
 209         rgs.add(narg);
 210       }
 211     }
 212     return rgs;
 213   }
 214
 215   @Override
 216   public List<ArgumentI> getServiceParameters()
 217   {
 218     return getJwsArgsfromJaba(serviceOptions.getArguments());
 219   }
 220
 221   @Override
 222   public boolean presetExists(String name)
 223   {
 224     return (editedParams.containsKey(name) || servicePresets
 225             .containsKey(name));
 226   }
 227
 228   @Override
 229   public void deletePreset(String name)
 230   {
 231     if (editedParams.containsKey(name))
 232     {
 233       WsParamSetI parameterSet = editedParams.get(name);
 234       editedParams.remove(name);
 235       if (manager != null)
 236       {
 237         manager.deleteParameterSet(parameterSet);
 238       }
 239       return;
 240     }
 241     if (servicePresets.containsKey(name))
 242     {
 243       throw new Error(
 244               "Implementation error: Attempt to delete a service preset!");
 245     }
 246   }
 247
 248   @Override
 249   public void storePreset(String presetName, String text,
 250           List<ArgumentI> jobParams)
 251   {
 252     JabaWsParamSet jps = new JabaWsParamSet(presetName, text, jobParams);
 253     jps.setApplicableUrls(new String[]
 254     { service.getUri() });
 255     editedParams.put(jps.getName(), jps);
 256     if (manager != null)
 257     {
 258       manager.storeParameterSet(jps);
 259     }
 260   }
 261
 262   @Override
 263   public void updatePreset(String oldName, String presetName, String text,
 264           List<ArgumentI> jobParams)
 265   {
 266     JabaWsParamSet jps = (JabaWsParamSet) ((oldName != null) ? getPreset(oldName)
 267             : getPreset(presetName));
 268     if (jps == null)
 269     {
 270       throw new Error("Implementation error: Can't locate either oldname ("
 271               + oldName + ") or presetName (" + presetName
 272               + "in the datastore!");
 273     }
 274     jps.setName(presetName);
 275     jps.setDescription(text);
 276     jps.setArguments(jobParams);
 277     jps.setApplicableUrls(new String[]
 278     { service.getUri() });
 279     if (oldName != null && !oldName.equals(jps.getName()))
 280     {
 281       editedParams.remove(oldName);
 282     }
 283     editedParams.put(jps.getName(), jps);
 284
 285     if (manager != null)
 286     {
 287       manager.storeParameterSet(jps);
 288     }
 289   }
 290
 291   /**
 292    * create a new, empty parameter set for this service
 293    *
 294    * @return
 295    */
 296   WsParamSetI newWsParamSet()
 297   {
 298     return new JabaWsParamSet();
 299   };
 300
 301   private boolean involves(String[] urls)
 302   {
 303     boolean found = false;
 304     for (String url : urls)
 305     {
 306       if (service.getServiceTypeURI().equals(url)
 307               || service.getUri().equalsIgnoreCase(url))
 308       {
 309         found = true;
 310         break;
 311       }
 312     }
 313     return found;
 314   }
 315
 316   @Override
 317   public WsParamSetI parseServiceParameterFile(String name, String descr,
 318           String[] urls, String parameterfile) throws IOException
 319   {
 320     if (!involves(urls))
 321     {
 322       throw new IOException(
 323               "Implementation error: Cannot find service url in the given url set!");
 324
 325     }
 326     JabaWsParamSet wsp = new JabaWsParamSet();
 327     wsp.setName(name);
 328     wsp.setDescription(descr);
 329     wsp.setApplicableUrls(urls.clone());
 330
 331     List<String> lines = new ArrayList<String>();
 332     StringTokenizer st = new StringTokenizer(parameterfile, "\n");
 333     while (st.hasMoreTokens())
 334     {
 335       lines.add(st.nextToken());
 336     }
 337     wsp.setjabaArguments(ParameterUtils.processParameters(lines,
 338             serviceOptions, " "));
 339     return wsp;
 340   }
 341
 342   @Override
 343   public String generateServiceParameterFile(WsParamSetI pset)
 344           throws IOException
 345   {
 346     if (!involves(pset.getApplicableUrls()))
 347     {
 348       throw new IOException(
 349               "Implementation error: Cannot find service url in the given url set for this service parameter store ("
 350                       + service.getUri() + ") !");
 351
 352     }
 353     if (!(pset instanceof JabaWsParamSet))
 354     {
 355       throw new Error(
 356               "Implementation error: JabaWsParamSets can only be handled by JabaParamStore");
 357     }
 358
 359     StringBuffer rslt = new StringBuffer();
 360     for (String ln : ParameterUtils.writeParameterSet(
 361             ((JabaWsParamSet) pset).getjabaArguments(), " "))
 362     {
 363       rslt.append(ln);
 364       rslt.append("\n");
 365     }
 366     ;
 367     return rslt.toString();
 368   }
 369
 370 }