src/jalview/ws/jws2/JabaParamStore.java

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