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