src/jalview/ws/jws2/Jws2Discoverer.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.bin.Cache;
  24 import jalview.gui.AlignFrame;
  25 import jalview.gui.Desktop;
  26 import jalview.gui.JvSwingUtils;
  27 import jalview.util.MessageManager;
  28 import jalview.ws.WSMenuEntryProviderI;
  29 import jalview.ws.jws2.jabaws2.Jws2Instance;
  30 import jalview.ws.params.ParamDatastoreI;
  31
  32 import java.awt.Color;
  33 import java.awt.event.ActionEvent;
  34 import java.awt.event.ActionListener;
  35 import java.beans.PropertyChangeEvent;
  36 import java.beans.PropertyChangeListener;
  37 import java.beans.PropertyChangeSupport;
  38 import java.net.MalformedURLException;
  39 import java.net.URL;
  40 import java.util.ArrayList;
  41 import java.util.Arrays;
  42 import java.util.HashMap;
  43 import java.util.HashSet;
  44 import java.util.Hashtable;
  45 import java.util.List;
  46 import java.util.Map;
  47 import java.util.Set;
  48 import java.util.StringTokenizer;
  49 import java.util.Vector;
  50
  51 import javax.swing.JMenu;
  52 import javax.swing.JMenuItem;
  53
  54 import compbio.ws.client.Services;
  55
  56 /**
  57  * discoverer for jws2 services. Follows the lightweight service discoverer
  58  * pattern (archetyped by EnfinEnvision2OneWay)
  59  *
  60  * @author JimP
  61  *
  62  */
  63 public class Jws2Discoverer implements Runnable, WSMenuEntryProviderI
  64 {
  65   public static final String COMPBIO_JABAWS = "http://www.compbio.dundee.ac.uk/jabaws";
  66
  67   /*
  68    * the .jalview_properties entry for JWS2 URLS
  69    */
  70   private final static String JWS2HOSTURLS = "JWS2HOSTURLS";
  71
  72   /*
  73    * Singleton instance
  74    */
  75   private static Jws2Discoverer discoverer;
  76
  77   /**
  78    * Returns the singleton instance of this class.
  79    *
  80    * @return
  81    */
  82   public static Jws2Discoverer getInstance()
  83   {
  84     if (discoverer == null)
  85     {
  86       discoverer = new Jws2Discoverer();
  87     }
  88     return discoverer;
  89   }
  90
  91   /*
  92    * Override for testing only
  93    */
  94   private static List<String> testUrls = null;
  95
  96   // preferred url has precedence over others
  97   private String preferredUrl;
  98
  99   private PropertyChangeSupport changeSupport = new PropertyChangeSupport(
 100           this);
 101
 102   private Vector<String> invalidServiceUrls = null;
 103
 104   private Vector<String> urlsWithoutServices = null;
 105
 106   private Vector<String> validServiceUrls = null;
 107
 108   private volatile boolean running = false;
 109
 110   private volatile boolean aborted = false;
 111
 112   private Thread oldthread = null;
 113
 114   /**
 115    * holds list of services.
 116    */
 117   protected Vector<Jws2Instance> services;
 118
 119   /**
 120    * Private constructor enforces use of singleton via getDiscoverer()
 121    */
 122   private Jws2Discoverer()
 123   {
 124   }
 125
 126   /**
 127    * change listeners are notified of "services" property changes
 128    *
 129    * @param listener
 130    *          to be added that consumes new services Hashtable object.
 131    */
 132   public void addPropertyChangeListener(
 133           java.beans.PropertyChangeListener listener)
 134   {
 135     changeSupport.addPropertyChangeListener(listener);
 136   }
 137
 138   /**
 139    *
 140    *
 141    * @param listener
 142    *          to be removed
 143    */
 144   public void removePropertyChangeListener(
 145           java.beans.PropertyChangeListener listener)
 146   {
 147     changeSupport.removePropertyChangeListener(listener);
 148   }
 149
 150   /**
 151    * @return the aborted
 152    */
 153   public boolean isAborted()
 154   {
 155     return aborted;
 156   }
 157
 158   /**
 159    * @param aborted
 160    *          the aborted to set
 161    */
 162   public void setAborted(boolean aborted)
 163   {
 164     this.aborted = aborted;
 165   }
 166
 167   @Override
 168   public void run()
 169   {
 170
 171     if (running && oldthread != null && oldthread.isAlive())
 172     {
 173       if (!aborted)
 174       {
 175         return;
 176       }
 177       while (running)
 178       {
 179         try
 180         {
 181           Cache.log.debug(
 182                   "Waiting around for old discovery thread to finish.");
 183           // wait around until old discoverer dies
 184           Thread.sleep(100);
 185         } catch (Exception e)
 186         {
 187         }
 188       }
 189       aborted = false;
 190       Cache.log.debug("Old discovery thread has finished.");
 191     }
 192     running = true;
 193
 194     // first set up exclusion list if needed
 195     final Set<String> ignoredServices = new HashSet<>();
 196     for (String ignored : Cache
 197             .getDefault("IGNORED_JABAWS_SERVICETYPES", "").split("\\|"))
 198     {
 199       ignoredServices.add(ignored);
 200     }
 201
 202     changeSupport.firePropertyChange("services", services,
 203             new Vector<Jws2Instance>());
 204     oldthread = Thread.currentThread();
 205     try
 206     {
 207       Class foo = getClass().getClassLoader()
 208               .loadClass("compbio.ws.client.Jws2Client");
 209     } catch (ClassNotFoundException e)
 210     {
 211       System.err.println(
 212               "Not enabling JABA Webservices : client jar is not available."
 213                       + "\nPlease check that your webstart JNLP file is up to date!");
 214       running = false;
 215       return;
 216     }
 217     // reinitialise records of good and bad service URLs
 218     if (services != null)
 219     {
 220       services.removeAllElements();
 221     }
 222     if (urlsWithoutServices != null)
 223     {
 224       urlsWithoutServices.removeAllElements();
 225     }
 226     if (invalidServiceUrls != null)
 227     {
 228       invalidServiceUrls.removeAllElements();
 229     }
 230     if (validServiceUrls != null)
 231     {
 232       validServiceUrls.removeAllElements();
 233     }
 234     ArrayList<String> svctypes = new ArrayList<>();
 235
 236     List<JabaWsServerQuery> qrys = new ArrayList<>();
 237     for (final String jwsserver : getServiceUrls())
 238     {
 239       JabaWsServerQuery squery = new JabaWsServerQuery(this, jwsserver);
 240       if (svctypes.size() == 0)
 241       {
 242         // TODO: remove this ugly hack to get Canonical JABA service ordering
 243         // for all possible services
 244         for (Services sv : squery.JABAWS2SERVERS)
 245         {
 246           if (!ignoredServices.contains(sv.toString()))
 247           {
 248             svctypes.add(sv.toString());
 249           }
 250         }
 251
 252       }
 253       qrys.add(squery);
 254       new Thread(squery).start();
 255     }
 256     boolean finished = true;
 257     do
 258     {
 259       finished = true;
 260       try
 261       {
 262         Thread.sleep(100);
 263       } catch (Exception e)
 264       {
 265       }
 266       for (JabaWsServerQuery squery : qrys)
 267       {
 268         if (squery.isRunning())
 269         {
 270           finished = false;
 271         }
 272       }
 273       if (aborted)
 274       {
 275         Cache.log.debug(
 276                 "Aborting " + qrys.size() + " JABAWS discovery threads.");
 277         for (JabaWsServerQuery squery : qrys)
 278         {
 279           squery.setQuit(true);
 280         }
 281       }
 282     } while (!aborted && !finished);
 283     if (!aborted)
 284     {
 285       // resort services according to order found in jabaws service list
 286       // also ensure services for each host are ordered in same way.
 287
 288       if (services != null && services.size() > 0)
 289       {
 290         Jws2Instance[] svcs = new Jws2Instance[services.size()];
 291         int[] spos = new int[services.size()];
 292         int ipos = 0;
 293         List<String> svcUrls = getServiceUrls();
 294         for (Jws2Instance svc : services)
 295         {
 296           svcs[ipos] = svc;
 297           spos[ipos++] = 1000 * svcUrls.indexOf(svc.getHost()) + 1
 298                   + svctypes.indexOf(svc.serviceType);
 299         }
 300         jalview.util.QuickSort.sort(spos, svcs);
 301         services = new Vector<>();
 302         for (Jws2Instance svc : svcs)
 303         {
 304           if (!ignoredServices.contains(svc.serviceType))
 305           {
 306             services.add(svc);
 307           }
 308         }
 309       }
 310     }
 311     oldthread = null;
 312     running = false;
 313     changeSupport.firePropertyChange("services", new Vector<Jws2Instance>(),
 314             services);
 315   }
 316
 317   /**
 318    * record this service endpoint so we can use it
 319    *
 320    * @param jwsservers
 321    * @param srv
 322    * @param service2
 323    */
 324   synchronized void addService(String jwsservers, Jws2Instance service)
 325   {
 326     if (services == null)
 327     {
 328       services = new Vector<>();
 329     }
 330     System.out.println(
 331             "Discovered service: " + jwsservers + " " + service.toString());
 332     // Jws2Instance service = new Jws2Instance(jwsservers, srv.toString(),
 333     // service2);
 334
 335     services.add(service);
 336     // retrieve the presets and parameter set and cache now
 337     ParamDatastoreI pds = service.getParamStore();
 338     if (pds != null)
 339     {
 340       pds.getPresets();
 341     }
 342     service.hasParameters();
 343     if (validServiceUrls == null)
 344     {
 345       validServiceUrls = new Vector<>();
 346     }
 347     validServiceUrls.add(jwsservers);
 348   }
 349
 350   /**
 351    * attach all available web services to the appropriate submenu in the given
 352    * JMenu
 353    */
 354   @Override
 355   public void attachWSMenuEntry(JMenu wsmenu, final AlignFrame alignFrame)
 356   {
 357     // dynamically regenerate service list.
 358     populateWSMenuEntry(wsmenu, alignFrame, null);
 359   }
 360
 361   private boolean isRecalculable(String action)
 362   {
 363     return (action != null && action.equalsIgnoreCase("conservation"));
 364   }
 365
 366   private void populateWSMenuEntry(JMenu jws2al,
 367           final AlignFrame alignFrame, String typeFilter)
 368   {
 369     if (running || services == null || services.size() == 0)
 370     {
 371       return;
 372     }
 373
 374     /**
 375      * eventually, JWS2 services will appear under the same align/etc submenus.
 376      * for moment we keep them separate.
 377      */
 378     JMenu atpoint;
 379     List<Jws2Instance> enumerableServices = new ArrayList<>();
 380     // jws2al.removeAll();
 381     Map<String, Jws2Instance> preferredHosts = new HashMap<>();
 382     Map<String, List<Jws2Instance>> alternates = new HashMap<>();
 383     for (Jws2Instance service : services.toArray(new Jws2Instance[0]))
 384     {
 385       if (!isRecalculable(service.action))
 386       {
 387         // add 'one shot' services to be displayed using the classic menu
 388         // structure
 389         enumerableServices.add(service);
 390       }
 391       else
 392       {
 393         if (!preferredHosts.containsKey(service.serviceType))
 394         {
 395           Jws2Instance preferredInstance = getPreferredServiceFor(
 396                   alignFrame, service.serviceType);
 397           if (preferredInstance != null)
 398           {
 399             preferredHosts.put(service.serviceType, preferredInstance);
 400           }
 401           else
 402           {
 403             preferredHosts.put(service.serviceType, service);
 404           }
 405         }
 406         List<Jws2Instance> ph = alternates.get(service.serviceType);
 407         if (preferredHosts.get(service.serviceType) != service)
 408         {
 409           if (ph == null)
 410           {
 411             ph = new ArrayList<>();
 412           }
 413           ph.add(service);
 414           alternates.put(service.serviceType, ph);
 415         }
 416       }
 417
 418     }
 419
 420     // create GUI element for classic services
 421     addEnumeratedServices(jws2al, alignFrame, enumerableServices);
 422     // and the instantaneous services
 423     for (final Jws2Instance service : preferredHosts.values())
 424     {
 425       atpoint = JvSwingUtils.findOrCreateMenu(jws2al, service.action);
 426       JMenuItem hitm;
 427       if (atpoint.getItemCount() > 1)
 428       {
 429         // previous service of this type already present
 430         atpoint.addSeparator();
 431       }
 432       atpoint.add(hitm = new JMenuItem(service.getHost()));
 433       hitm.setForeground(Color.blue);
 434       hitm.addActionListener(new ActionListener()
 435       {
 436
 437         @Override
 438         public void actionPerformed(ActionEvent e)
 439         {
 440           Desktop.showUrl(service.getHost());
 441         }
 442       });
 443       hitm.setToolTipText(JvSwingUtils.wrapTooltip(false,
 444               MessageManager.getString("label.open_jabaws_web_page")));
 445
 446       service.attachWSMenuEntry(atpoint, alignFrame);
 447       if (alternates.containsKey(service.serviceType))
 448       {
 449         atpoint.add(hitm = new JMenu(
 450                 MessageManager.getString("label.switch_server")));
 451         hitm.setToolTipText(JvSwingUtils.wrapTooltip(false,
 452                 MessageManager.getString("label.choose_jabaws_server")));
 453         for (final Jws2Instance sv : alternates.get(service.serviceType))
 454         {
 455           JMenuItem itm;
 456           hitm.add(itm = new JMenuItem(sv.getHost()));
 457           itm.setForeground(Color.blue);
 458           itm.addActionListener(new ActionListener()
 459           {
 460
 461             @Override
 462             public void actionPerformed(ActionEvent arg0)
 463             {
 464               new Thread(new Runnable()
 465               {
 466                 @Override
 467                 public void run()
 468                 {
 469                   setPreferredServiceFor(alignFrame, sv.serviceType,
 470                           sv.action, sv);
 471                   changeSupport.firePropertyChange("services",
 472                           new Vector<Jws2Instance>(), services);
 473                 }
 474               }).start();
 475
 476             }
 477           });
 478         }
 479       }
 480     }
 481   }
 482
 483   /**
 484    * add services using the Java 2.5/2.6/2.7 system which optionally creates
 485    * submenus to index by host and service program type
 486    */
 487   private void addEnumeratedServices(final JMenu jws2al,
 488           final AlignFrame alignFrame,
 489           List<Jws2Instance> enumerableServices)
 490   {
 491     boolean byhost = Cache.getDefault("WSMENU_BYHOST", false),
 492             bytype = Cache.getDefault("WSMENU_BYTYPE", false);
 493     /**
 494      * eventually, JWS2 services will appear under the same align/etc submenus.
 495      * for moment we keep them separate.
 496      */
 497     JMenu atpoint;
 498
 499     List<String> hostLabels = new ArrayList<>();
 500     Hashtable<String, String> lasthostFor = new Hashtable<>();
 501     Hashtable<String, ArrayList<Jws2Instance>> hosts = new Hashtable<>();
 502     ArrayList<String> hostlist = new ArrayList<>();
 503     for (Jws2Instance service : enumerableServices)
 504     {
 505       ArrayList<Jws2Instance> hostservices = hosts.get(service.getHost());
 506       if (hostservices == null)
 507       {
 508         hosts.put(service.getHost(),
 509                 hostservices = new ArrayList<>());
 510         hostlist.add(service.getHost());
 511       }
 512       hostservices.add(service);
 513     }
 514     // now add hosts in order of the given array
 515     for (String host : hostlist)
 516     {
 517       Jws2Instance orderedsvcs[] = hosts.get(host)
 518               .toArray(new Jws2Instance[1]);
 519       String sortbytype[] = new String[orderedsvcs.length];
 520       for (int i = 0; i < sortbytype.length; i++)
 521       {
 522         sortbytype[i] = orderedsvcs[i].serviceType;
 523       }
 524       jalview.util.QuickSort.sort(sortbytype, orderedsvcs);
 525       for (final Jws2Instance service : orderedsvcs)
 526       {
 527         atpoint = JvSwingUtils.findOrCreateMenu(jws2al, service.action);
 528         String type = service.serviceType;
 529         if (byhost)
 530         {
 531           atpoint = JvSwingUtils.findOrCreateMenu(atpoint, host);
 532           if (atpoint.getToolTipText() == null)
 533           {
 534             atpoint.setToolTipText(MessageManager
 535                     .formatMessage("label.services_at", new String[]
 536                     { host }));
 537           }
 538         }
 539         if (bytype)
 540         {
 541           atpoint = JvSwingUtils.findOrCreateMenu(atpoint, type);
 542           if (atpoint.getToolTipText() == null)
 543           {
 544             atpoint.setToolTipText(service.getActionText());
 545           }
 546         }
 547         if (!byhost && !hostLabels.contains(
 548                 host + service.serviceType + service.getActionText()))
 549         // !hostLabels.contains(host + (bytype ?
 550         // service.serviceType+service.getActionText() : "")))
 551         {
 552           // add a marker indicating where this service is hosted
 553           // relies on services from the same host being listed in a
 554           // contiguous
 555           // group
 556           JMenuItem hitm;
 557           if (hostLabels.contains(host))
 558           {
 559             atpoint.addSeparator();
 560           }
 561           else
 562           {
 563             hostLabels.add(host);
 564           }
 565           if (lasthostFor.get(service.action) == null
 566                   || !lasthostFor.get(service.action).equals(host))
 567           {
 568             atpoint.add(hitm = new JMenuItem(host));
 569             hitm.setForeground(Color.blue);
 570             hitm.addActionListener(new ActionListener()
 571             {
 572
 573               @Override
 574               public void actionPerformed(ActionEvent e)
 575               {
 576                 Desktop.showUrl(service.getHost());
 577               }
 578             });
 579             hitm.setToolTipText(
 580                     JvSwingUtils.wrapTooltip(true, MessageManager
 581                             .getString("label.open_jabaws_web_page")));
 582             lasthostFor.put(service.action, host);
 583           }
 584           hostLabels.add(
 585                   host + service.serviceType + service.getActionText());
 586         }
 587
 588         service.attachWSMenuEntry(atpoint, alignFrame);
 589       }
 590     }
 591   }
 592
 593   /**
 594    *
 595    * @param args
 596    * @j2sIgnore
 597    */
 598   public static void main(String[] args)
 599   {
 600     if (args.length > 0)
 601     {
 602       testUrls = new ArrayList<>();
 603       for (String url : args)
 604       {
 605         testUrls.add(url);
 606       }
 607     }
 608     Thread runner = getInstance()
 609             .startDiscoverer(new PropertyChangeListener()
 610             {
 611
 612               @Override
 613               public void propertyChange(PropertyChangeEvent evt)
 614               {
 615                 if (getInstance().services != null)
 616                 {
 617                   System.out.println("Changesupport: There are now "
 618                           + getInstance().services.size() + " services");
 619                   int i = 1;
 620                   for (Jws2Instance instance : getInstance().services)
 621                   {
 622                     System.out.println("Service " + i++ + " "
 623                             + instance.getClass() + "@" + instance.getHost()
 624                             + ": " + instance.getActionText());
 625                   }
 626
 627                 }
 628               }
 629             });
 630     while (runner.isAlive())
 631     {
 632       try
 633       {
 634         Thread.sleep(50);
 635       } catch (InterruptedException e)
 636       {
 637       }
 638     }
 639     try
 640     {
 641       Thread.sleep(50);
 642     } catch (InterruptedException x)
 643     {
 644     }
 645   }
 646
 647
 648   public boolean hasServices()
 649   {
 650     return !running && services != null && services.size() > 0;
 651   }
 652
 653   public boolean isRunning()
 654   {
 655     return running;
 656   }
 657
 658   public void setServiceUrls(List<String> wsUrls)
 659   {
 660     if (wsUrls != null && !wsUrls.isEmpty())
 661     {
 662       StringBuilder urls = new StringBuilder(128);
 663       String sep = "";
 664       for (String url : wsUrls)
 665       {
 666         urls.append(sep);
 667         urls.append(url);
 668         sep = ",";
 669       }
 670       Cache.setProperty(JWS2HOSTURLS, urls.toString());
 671     }
 672     else
 673     {
 674       Cache.removeProperty(JWS2HOSTURLS);
 675     }
 676   }
 677
 678   /**
 679    * Returns web service URLs, in the order in which they should be tried (or an
 680    * empty list).
 681    *
 682    * @return
 683    */
 684   public List<String> getServiceUrls()
 685   {
 686     if (testUrls != null)
 687     {
 688       // return test urls, if there are any, instead of touching cache
 689       return testUrls;
 690     }
 691     List<String> urls = new ArrayList<>();
 692
 693     if (this.preferredUrl != null)
 694     {
 695       urls.add(preferredUrl);
 696     }
 697
 698     String surls = Cache.getDefault(JWS2HOSTURLS, COMPBIO_JABAWS);
 699     try
 700     {
 701       StringTokenizer st = new StringTokenizer(surls, ",");
 702       while (st.hasMoreElements())
 703       {
 704         String url = null;
 705         try
 706         {
 707           url = st.nextToken();
 708           new URL(url);
 709           if (!urls.contains(url))
 710           {
 711             urls.add(url);
 712           }
 713           else
 714           {
 715             Cache.log.warn("Ignoring duplicate url " + url + " in "
 716                     + JWS2HOSTURLS + " list");
 717           }
 718         } catch (MalformedURLException ex)
 719         {
 720           Cache.log.warn("Problem whilst trying to make a URL from '"
 721                   + ((url != null) ? url : "<null>") + "'");
 722           Cache.log.warn(
 723                   "This was probably due to a malformed comma separated list"
 724                           + " in the " + JWS2HOSTURLS
 725                           + " entry of $(HOME)/.jalview_properties)");
 726           Cache.log.debug("Exception was ", ex);
 727         }
 728       }
 729     } catch (Exception ex)
 730     {
 731       Cache.log.warn("Error parsing comma separated list of urls in "
 732               + JWS2HOSTURLS + " preference.", ex);
 733     }
 734     return urls;
 735   }
 736
 737   public Vector<Jws2Instance> getServices()
 738   {
 739     return (services == null) ? new Vector<>()
 740             : new Vector<>(services);
 741   }
 742
 743   /**
 744    * test the given URL with the JabaWS test code
 745    *
 746    * @param foo
 747    * @return
 748    */
 749   public static boolean testServiceUrl(URL foo)
 750   {
 751     try
 752     {
 753       compbio.ws.client.WSTester
 754               .main(new String[]
 755               { "-h=" + foo.toString() });
 756     } catch (Exception e)
 757     {
 758       e.printStackTrace();
 759       return false;
 760     } catch (OutOfMemoryError e)
 761     {
 762       e.printStackTrace();
 763       return false;
 764     } catch (Error e)
 765     {
 766       e.printStackTrace();
 767       return false;
 768     }
 769
 770     return true;
 771   }
 772
 773   public boolean restart()
 774   {
 775     synchronized (this)
 776     {
 777       if (running)
 778       {
 779         aborted = true;
 780       }
 781       else
 782       {
 783         running = true;
 784       }
 785       return aborted;
 786     }
 787   }
 788
 789   /**
 790    * Start a fresh discovery thread and notify the given object when we're
 791    * finished. Any known existing threads will be killed before this one is
 792    * started.
 793    *
 794    * @param changeSupport2
 795    * @return new thread
 796    */
 797   public Thread startDiscoverer(PropertyChangeListener changeSupport2)
 798   {
 799     /*    if (restart())
 800         {
 801           return;
 802         }
 803         else
 804         {
 805           Thread thr = new Thread(this);
 806           thr.start();
 807         }
 808        */
 809     if (isRunning())
 810     {
 811       setAborted(true);
 812     }
 813     addPropertyChangeListener(changeSupport2);
 814     Thread thr = new Thread(this);
 815     thr.start();
 816     return thr;
 817   }
 818
 819   /**
 820    * @return the invalidServiceUrls
 821    */
 822   public Vector<String> getInvalidServiceUrls()
 823   {
 824     return invalidServiceUrls;
 825   }
 826
 827   /**
 828    * @return the urlsWithoutServices
 829    */
 830   public Vector<String> getUrlsWithoutServices()
 831   {
 832     return urlsWithoutServices;
 833   }
 834
 835   /**
 836    * add an 'empty' JABA server to the list. Only servers not already in the
 837    * 'bad URL' list will be added to this list.
 838    *
 839    * @param jwsservers
 840    */
 841   public synchronized void addUrlwithnoservices(String jwsservers)
 842   {
 843     if (urlsWithoutServices == null)
 844     {
 845       urlsWithoutServices = new Vector<>();
 846     }
 847
 848     if ((invalidServiceUrls == null
 849             || !invalidServiceUrls.contains(jwsservers))
 850             && !urlsWithoutServices.contains(jwsservers))
 851     {
 852       urlsWithoutServices.add(jwsservers);
 853     }
 854   }
 855
 856   /**
 857    * add a bad URL to the list
 858    *
 859    * @param jwsservers
 860    */
 861   public synchronized void addInvalidServiceUrl(String jwsservers)
 862   {
 863     if (invalidServiceUrls == null)
 864     {
 865       invalidServiceUrls = new Vector<>();
 866     }
 867     if (!invalidServiceUrls.contains(jwsservers))
 868     {
 869       invalidServiceUrls.add(jwsservers);
 870     }
 871   }
 872
 873   /**
 874    *
 875    * @return a human readable report of any problems with the service URLs used
 876    *         for discovery
 877    */
 878   public String getErrorMessages()
 879   {
 880     if (!isRunning() && !isAborted())
 881     {
 882       StringBuffer ermsg = new StringBuffer();
 883       boolean list = false;
 884       if (getInvalidServiceUrls() != null
 885               && getInvalidServiceUrls().size() > 0)
 886       {
 887         ermsg.append(MessageManager.getString("warn.urls_not_contacted")
 888                 + ": \n");
 889         for (String svcurl : getInvalidServiceUrls())
 890         {
 891           if (list)
 892           {
 893             ermsg.append(", ");
 894           }
 895           list = true;
 896           ermsg.append(svcurl);
 897         }
 898         ermsg.append("\n\n");
 899       }
 900       list = false;
 901       if (getUrlsWithoutServices() != null
 902               && getUrlsWithoutServices().size() > 0)
 903       {
 904         ermsg.append(
 905                 MessageManager.getString("warn.urls_no_jaba") + ": \n");
 906         for (String svcurl : getUrlsWithoutServices())
 907         {
 908           if (list)
 909           {
 910             ermsg.append(", ");
 911           }
 912           list = true;
 913           ermsg.append(svcurl);
 914         }
 915         ermsg.append("\n");
 916       }
 917       if (ermsg.length() > 1)
 918       {
 919         return ermsg.toString();
 920       }
 921
 922     }
 923     return null;
 924   }
 925
 926   public int getServerStatusFor(String url)
 927   {
 928     if (validServiceUrls != null && validServiceUrls.contains(url))
 929     {
 930       return 1;
 931     }
 932     if (urlsWithoutServices != null && urlsWithoutServices.contains(url))
 933     {
 934       return 0;
 935     }
 936     if (invalidServiceUrls != null && invalidServiceUrls.contains(url))
 937     {
 938       return -1;
 939     }
 940     return -2;
 941   }
 942
 943   /**
 944    * pick the user's preferred service based on a set of URLs (jaba server
 945    * locations) and service URIs (specifying version and service interface
 946    * class)
 947    *
 948    * @param serviceURL
 949    * @return null or best match for given uri/ls.
 950    */
 951   public Jws2Instance getPreferredServiceFor(String[] serviceURLs)
 952   {
 953     HashSet<String> urls = new HashSet<>();
 954     urls.addAll(Arrays.asList(serviceURLs));
 955     Jws2Instance match = null;
 956     if (services != null)
 957     {
 958       for (Jws2Instance svc : services)
 959       {
 960         if (urls.contains(svc.getServiceTypeURI()))
 961         {
 962           if (match == null)
 963           {
 964             // for moment we always pick service from server ordered first in
 965             // user's preferences
 966             match = svc;
 967           }
 968           if (urls.contains(svc.getUri()))
 969           {
 970             // stop and return - we've matched type URI and URI for service
 971             // endpoint
 972             return svc;
 973           }
 974         }
 975       }
 976     }
 977     return match;
 978   }
 979
 980   Map<String, Map<String, String>> preferredServiceMap = new HashMap<>();
 981
 982   /**
 983    * get current preferred service of the given type, or global default
 984    *
 985    * @param af
 986    *          null or a specific alignFrame
 987    * @param serviceType
 988    *          Jws2Instance.serviceType for service
 989    * @return null if no service of this type is available, the preferred service
 990    *         for the serviceType and af if specified and if defined.
 991    */
 992   public Jws2Instance getPreferredServiceFor(AlignFrame af,
 993           String serviceType)
 994   {
 995     String serviceurl = null;
 996     synchronized (preferredServiceMap)
 997     {
 998       String afid = (af == null) ? "" : af.getViewport().getSequenceSetId();
 999       Map<String, String> prefmap = preferredServiceMap.get(afid);
1000       if (afid.length() > 0 && prefmap == null)
1001       {
1002         // recover global setting, if any
1003         prefmap = preferredServiceMap.get("");
1004       }
1005       if (prefmap != null)
1006       {
1007         serviceurl = prefmap.get(serviceType);
1008       }
1009
1010     }
1011     Jws2Instance response = null;
1012     for (Jws2Instance svc : services)
1013     {
1014       if (svc.serviceType.equals(serviceType))
1015       {
1016         if (serviceurl == null || serviceurl.equals(svc.getHost()))
1017         {
1018           response = svc;
1019           break;
1020         }
1021       }
1022     }
1023     return response;
1024   }
1025
1026   public void setPreferredServiceFor(AlignFrame af, String serviceType,
1027           String serviceAction, Jws2Instance selectedServer)
1028   {
1029     String afid = (af == null) ? "" : af.getViewport().getSequenceSetId();
1030     if (preferredServiceMap == null)
1031     {
1032       preferredServiceMap = new HashMap<>();
1033     }
1034     Map<String, String> prefmap = preferredServiceMap.get(afid);
1035     if (prefmap == null)
1036     {
1037       prefmap = new HashMap<>();
1038       preferredServiceMap.put(afid, prefmap);
1039     }
1040     prefmap.put(serviceType, selectedServer.getHost());
1041     prefmap.put(serviceAction, selectedServer.getHost());
1042   }
1043
1044   public void setPreferredServiceFor(String serviceType,
1045           String serviceAction, Jws2Instance selectedServer)
1046   {
1047     setPreferredServiceFor(null, serviceType, serviceAction,
1048             selectedServer);
1049   }
1050
1051   /**
1052    * Set a URL to try before any others. For use with command-line parameter to
1053    * configure a local Jabaws installation without the need to add to property
1054    * files.
1055    *
1056    * @param value
1057    * @throws MalformedURLException
1058    */
1059   public void setPreferredUrl(String value) throws MalformedURLException
1060   {
1061     if (value != null && value.trim().length() > 0)
1062     {
1063       new URL(value);
1064       preferredUrl = value;
1065     }
1066   }
1067 }