src/jalview/ws/jws2/JabaWsServerQuery.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer (Version 2.9)
   3  * Copyright (C) 2015 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 /**
  22  *
  23  */
  24 package jalview.ws.jws2;
  25
  26 import jalview.bin.Cache;
  27 import jalview.ws.jws2.jabaws2.Jws2Instance;
  28 import jalview.ws.jws2.jabaws2.Jws2InstanceFactory;
  29
  30 import java.io.IOException;
  31 import java.net.MalformedURLException;
  32 import java.net.URL;
  33 import java.util.HashSet;
  34 import java.util.Set;
  35
  36 import compbio.data.msa.Category;
  37 import compbio.data.msa.JABAService;
  38 import compbio.ws.client.Jws2Client;
  39 import compbio.ws.client.Services;
  40
  41 /**
  42  * @author JimP
  43  *
  44  */
  45 public class JabaWsServerQuery implements Runnable
  46 {
  47
  48   Jws2Discoverer jws2Discoverer = null;
  49
  50   String jwsserver = null;
  51
  52   boolean quit = false, running = false;
  53
  54   /**
  55    * @return the running
  56    */
  57   public boolean isRunning()
  58   {
  59     return running;
  60   }
  61
  62   /**
  63    * @param quit
  64    *          the quit to set
  65    */
  66   public void setQuit(boolean quit)
  67   {
  68     this.quit = quit;
  69   }
  70
  71   public JabaWsServerQuery(Jws2Discoverer jws2Discoverer, String server)
  72   {
  73     this.jws2Discoverer = jws2Discoverer;
  74     this.jwsserver = server;
  75   }
  76
  77   Services[] JABAWS1SERVERS = new Services[] { Services.ClustalWS,
  78       Services.MuscleWS, Services.MafftWS, Services.ProbconsWS,
  79       Services.TcoffeeWS };
  80
  81   Services[] JABAWS2SERVERS = new Services[] { Services.ClustalWS,
  82       Services.MuscleWS, Services.MafftWS, Services.ProbconsWS,
  83       Services.TcoffeeWS, Services.AAConWS, Services.DisemblWS,
  84       Services.GlobPlotWS, Services.IUPredWS, Services.JronnWS,
  85       Services.RNAalifoldWS };
  86
  87   /*
  88    * (non-Javadoc)
  89    *
  90    * @see java.lang.Runnable#run()
  91    */
  92   @Override
  93   public void run()
  94   {
  95     running = true;
  96     try
  97     {
  98       // TODO this test doesn't seem to attempt a connection - should it?
  99       // would save a lot of failed tries with UnknownHostException
 100       if (isValidUrl(jwsserver))
 101       {
 102         compbio.data.msa.RegistryWS registry = null;
 103         Set svccategories = null;
 104         boolean noservices = true;
 105         // look for services
 106         boolean jabasws2 = false;
 107         // If we are dealing with a JABAWS2 service, then just go and ask the
 108         // JABAWS 2 service registry
 109         Set<Services> srv_set = new HashSet<Services>();
 110
 111         Set<Category> categories = Category.getCategories();
 112         String svc_cat;
 113
 114         try
 115         {
 116           // JBPNote: why is RegistryWS in compbio.data.msa ?
 117           registry = Jws2Client.connectToRegistry(jwsserver);
 118           if (registry != null)
 119           {
 120             // System.err.println("Test Services Output\n"
 121             // + registry.testAllServices());
 122             // TODO: enumerate services and test those that haven't been tested
 123             // in the last n-days/hours/etc.
 124
 125             jabasws2 = true;
 126             srv_set = registry.getSupportedServices();
 127
 128             // dan test
 129             System.out.println("registry.getSupportedServices: "
 130                     + srv_set.toString());
 131
 132             svccategories = registry.getServiceCategories();
 133
 134             // dan test
 135             // System.out.println("registry.getServiceCategories: " +
 136             // svccategories.toString());
 137
 138           }
 139         } catch (Exception ex)
 140         {
 141           System.err.println("Exception whilst trying to get at registry:");
 142           ex.printStackTrace();
 143           // if that failed, then we are probably working with a JABAWS1 server.
 144           // in that case, look for each service endpoint
 145           System.err.println("JWS2 Discoverer: " + jwsserver
 146                   + " is a JABAWS1 server. Using hardwired list.");
 147           for (Services srv : JABAWS1SERVERS)
 148           {
 149             srv_set.add(srv);
 150           }
 151         }
 152
 153         for (Category cat : categories)
 154         {
 155           for (Services srv : cat.getServices())
 156           {
 157             if (quit)
 158             {
 159               running = false;
 160               return;
 161             }
 162             if (!srv_set.contains(srv))
 163             {
 164               continue;
 165             }
 166             JABAService service = null;
 167             try
 168             {
 169               service = Jws2Client.connect(jwsserver, srv);
 170             } catch (Exception e)
 171             {
 172               System.err.println("Jws2 Discoverer: Problem on " + jwsserver
 173                       + " with service " + srv + ":\n" + e.getMessage());
 174               if (!(e instanceof javax.xml.ws.WebServiceException))
 175               {
 176                 e.printStackTrace();
 177               }
 178               // For moment, report service as a problem.
 179               jws2Discoverer.addInvalidServiceUrl(jwsserver);
 180             }
 181             ;
 182             if (service != null
 183                     && !Jws2InstanceFactory.ignoreService(srv.toString()))
 184             {
 185               noservices = false;
 186               Jws2Instance svc = null;
 187               if (registry != null)
 188               {
 189
 190                 String description = registry.getServiceDescription(srv);
 191
 192                 svc = Jws2InstanceFactory.newJws2Instance(jwsserver,
 193                         srv.toString(), cat.name, description, service);
 194               }
 195               if (svc == null)
 196               {
 197                 svc = Jws2InstanceFactory.newJws2Instance(jwsserver,
 198                         srv.toString(), cat.name,
 199                         "JABAWS 1 Alignment Service", service);
 200               }
 201               jws2Discoverer.addService(jwsserver, svc);
 202             }
 203
 204           }
 205         }
 206
 207         if (noservices)
 208         {
 209           jws2Discoverer.addUrlwithnoservices(jwsserver);
 210         }
 211       }
 212       else
 213       {
 214         jws2Discoverer.addInvalidServiceUrl(jwsserver);
 215         Cache.log.warn("Ignoring invalid Jws2 service url " + jwsserver);
 216       }
 217     } catch (Exception e)
 218     {
 219       e.printStackTrace();
 220       Cache.log.warn("Exception when discovering Jws2 services.", e);
 221       jws2Discoverer.addInvalidServiceUrl(jwsserver);
 222     } catch (Error e)
 223     {
 224       Cache.log.error("Exception when discovering Jws2 services.", e);
 225       jws2Discoverer.addInvalidServiceUrl(jwsserver);
 226     }
 227     running = false;
 228   }
 229
 230   /**
 231    * Check if the URL is valid and responding.
 232    *
 233    * @return
 234    */
 235   private boolean isValidUrl(String server)
 236   {
 237     // return Jws2Client.validURL(jwsserver); // checks syntax only
 238     boolean result = false;
 239     if (server != null)
 240     {
 241       try
 242       {
 243         URL url = new URL(server);
 244         url.openStream().close();
 245         result = true;
 246       } catch (MalformedURLException e)
 247       {
 248         System.err.println("Invalid server URL: " + server);
 249         result = false;
 250       } catch (IOException e)
 251       {
 252         System.err.println("Error connecting to server: " + server + ": "
 253                 + e.toString());
 254         result = false;
 255       }
 256     }
 257     return result;
 258   }
 259
 260 }