src/jalview/ws/jws2/JabaParamStore.java

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