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