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