X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Fjalview%2Fws%2Fslivkaws%2FSlivkaWSDiscoverer.java;h=d290024937c859f62319382be3a0ad8060c4e6a7;hb=95f4ae66fbaecbbdc1c3ab3c6c9c611a3a9a3e46;hp=b1c9ecb82bb26251af774d27bd25febacd54dfeb;hpb=e9f72a456e6ead6ed3efc3f6b6011d73a80c40f9;p=jalview.git

diff --git a/src/jalview/ws/slivkaws/SlivkaWSDiscoverer.java b/src/jalview/ws/slivkaws/SlivkaWSDiscoverer.java
index b1c9ecb..d290024 100644
--- a/src/jalview/ws/slivkaws/SlivkaWSDiscoverer.java
+++ b/src/jalview/ws/slivkaws/SlivkaWSDiscoverer.java
@@ -1,37 +1,39 @@
 package jalview.ws.slivkaws;
 
-import jalview.gui.AlignFrame;
-import jalview.ws.WSMenuEntryProviderI;
+import jalview.bin.Cache;
+import jalview.ws.ServiceChangeListener;
+import jalview.ws.WSDiscovererI;
 import jalview.ws.api.ServiceWithParameters;
-import jalview.ws.jws2.PreferredServiceRegistry;
-
-import java.beans.PropertyChangeSupport;
-import java.io.IOError;
 import java.io.IOException;
-import java.net.URISyntaxException;
+import java.net.MalformedURLException;
+import java.net.URL;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
-
-import javax.swing.JMenu;
-
+import java.util.Set;
+import java.util.Vector;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CopyOnWriteArraySet;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+import compbio.data.msa.Category;
 import uk.ac.dundee.compbio.slivkaclient.SlivkaClient;
 import uk.ac.dundee.compbio.slivkaclient.SlivkaService;
 
-public class SlivkaWSDiscoverer implements Runnable, WSMenuEntryProviderI
+public class SlivkaWSDiscoverer implements WSDiscovererI
 {
+  private static final String SLIVKA_HOST_URLS = "SLIVKAHOSTURLS";
+
+  private static final String COMPBIO_SLIVKA = "https://www.compbio.dundee.ac.uk/slivka/";
+
   private static SlivkaWSDiscoverer instance = null;
 
-  private SlivkaClient slivkaClient;
+  private List<ServiceWithParameters> services = List.of();
 
   private SlivkaWSDiscoverer()
   {
-    try
-    {
-      slivkaClient = new SlivkaClient("localhost", 4954);
-    } catch (URISyntaxException e)
-    {
-      throw new RuntimeException(e);
-    }
   }
 
   public static SlivkaWSDiscoverer getInstance()
@@ -43,93 +45,187 @@ public class SlivkaWSDiscoverer implements Runnable, WSMenuEntryProviderI
     return instance;
   }
 
-  List<ServiceWithParameters> getServiceInstances()
+  private Set<ServiceChangeListener> serviceListeners = new CopyOnWriteArraySet<>();
+
+  @Override
+  public void addServiceChangeListener(ServiceChangeListener l)
+  {
+    serviceListeners.add(l);
+  }
+
+  @Override
+  public void removeServiceChangeListener(ServiceChangeListener l)
+  {
+    serviceListeners.remove(l);
+  }
+
+  public void notifyServiceListeners(List<ServiceWithParameters> services)
   {
-    List<ServiceWithParameters> instances = new ArrayList<>();
-    for (SlivkaService service : services)
+    for (var listener : serviceListeners)
     {
-      for (String classifier : service.classifiers)
+      listener.servicesChanged(this, services);
+    }
+  }
+
+  private final ExecutorService executor = Executors
+          .newSingleThreadExecutor();
+
+  private Vector<Future<?>> discoveryTasks = new Vector<>();
+
+  public CompletableFuture<WSDiscovererI> startDiscoverer()
+  {
+    CompletableFuture<WSDiscovererI> task = CompletableFuture
+            .supplyAsync(() -> {
+              reloadServices();
+              return SlivkaWSDiscoverer.this;
+            }, executor);
+    discoveryTasks.add(task);
+    return task;
+  }
+
+  private List<ServiceWithParameters> reloadServices()
+  {
+    Cache.log.info("Reloading Slivka services");
+    notifyServiceListeners(Collections.emptyList());
+    ArrayList<ServiceWithParameters> instances = new ArrayList<>();
+
+    for (String url : getServiceUrls())
+    {
+      SlivkaClient client = new SlivkaClient(url);
+
+      List<SlivkaService> services;
+      try
       {
-        if (classifier.contains("Multiple sequence alignment"))
-        {
-          instances
-                  .add(new SlivkaMsaServiceInstance(slivkaClient, service));
-        }
-        else if (classifier.contains("Protein sequence analysis"))
-        {
-          instances.add(new SlivkaAnnotationServiceInstance(slivkaClient,
-                  service, false));
-        }
-        else if (classifier
-                .contains("Sequence alignment analysis (conservation)"))
+        services = client.getServices();
+      } catch (IOException e)
+      {
+        e.printStackTrace();
+        continue;
+      }
+      for (SlivkaService service : services)
+      {
+        SlivkaWSInstance newInstance = null;
+        for (String classifier : service.classifiers)
         {
-          instances.add(new SlivkaAnnotationServiceInstance(slivkaClient,
-                  service, true));
+          String[] path = classifier.split("\\s*::\\s*");
+          if (path.length >= 3 && path[0].toLowerCase().equals("operation")
+                  && path[1].toLowerCase().equals("analysis"))
+          {
+            switch (path[path.length - 1].toLowerCase())
+            {
+            case "sequence alignment analysis (conservation)":
+              newInstance = new SlivkaAnnotationServiceInstance(client,
+                      service, Category.CATEGORY_CONSERVATION);
+              break;
+            case "protein sequence analysis":
+              newInstance = new SlivkaAnnotationServiceInstance(client,
+                      service, Category.CATEGORY_DISORDER);
+              break;
+            case "protein secondary structure prediction":
+              newInstance = new SlivkaJPredServiceInstance(client,
+                      service, "Secondary Structure Prediction");
+              break;
+            case "multiple sequence alignment":
+              newInstance = new SlivkaMsaServiceInstance(client, service,
+                      Category.CATEGORY_ALIGNMENT);
+              break;
+            }
+          }
+          if (newInstance != null)
+            break;
         }
-
+        if (newInstance != null)
+          instances.add(newInstance);
       }
     }
+
+    services = instances;
+    Cache.log.info("Slivka services reloading finished");
+    notifyServiceListeners(instances);
     return instances;
   }
 
-  private PropertyChangeSupport changeSupport = new PropertyChangeSupport(
-          this);
-
   @Override
-  public void attachWSMenuEntry(JMenu wsmenu, final AlignFrame alignFrame)
+  public List<ServiceWithParameters> getServices()
   {
-    JMenu slivkaMenu = new JMenu("Slivka");
-    wsmenu.add(slivkaMenu);
-
-    JMenu alignmentMenu = new JMenu("Sequence Alignment");
-    slivkaMenu.add(alignmentMenu);
-    JMenu disorderMenu = new JMenu("Protein sequence analysis");
-    slivkaMenu.add(disorderMenu);
-    JMenu conservationMenu = new JMenu("Conservation");
-    slivkaMenu.add(conservationMenu);
-    PreferredServiceRegistry.getRegistry().populateWSMenuEntry(
-            getServiceInstances(),
-              changeSupport, slivkaMenu, alignFrame, null);
-    
+    return services;
   }
 
-  List<SlivkaService>services=null;
+  @Override
+  public boolean hasServices()
+  {
+    return !isRunning() && services.size() > 0;
+  }
 
-  volatile boolean started = false, finished = false;
+  @Override
+  public boolean isRunning()
+  {
+    return !discoveryTasks.stream().allMatch(Future::isDone);
+  }
 
-  Thread discoverer = null;
   @Override
-  public void run()
+  public void setServiceUrls(List<String> wsUrls)
   {
-    discoverer = Thread.currentThread();
-    started = true;
-    try
+    if (wsUrls != null && !wsUrls.isEmpty())
     {
-      services = slivkaClient.getServices();
-    } catch (IOException e)
+      Cache.setProperty(SLIVKA_HOST_URLS, String.join(",", wsUrls));
+    }
+    else
     {
-      throw new IOError(e);
+      Cache.removeProperty(SLIVKA_HOST_URLS);
     }
-    finished = true;
   }
 
-  public static List<ServiceWithParameters> getServices()
+  @Override
+  public List<String> getServiceUrls()
   {
-    SlivkaWSDiscoverer us = getInstance();
-    if (us.services == null)
+    String surls = Cache.getDefault(SLIVKA_HOST_URLS, COMPBIO_SLIVKA);
+    String[] urls = surls.split(",");
+    ArrayList<String> valid = new ArrayList<>(urls.length);
+    for (String url : urls)
     {
-      us.run();
+      try
+      {
+        new URL(url);
+        valid.add(url);
+      } catch (MalformedURLException e)
+      {
+        Cache.log.warn("Problem whilst trying to make a URL from '"
+                + ((url != null) ? url : "<null>") + "'");
+        Cache.log.warn(
+                "This was probably due to a malformed comma separated list"
+                        + " in the " + SLIVKA_HOST_URLS
+                        + " entry of $(HOME)/.jalview_properties)");
+        Cache.log.debug("Exception was ", e);
+      }
     }
-    return us.getServiceInstances();
+    return valid;
   }
 
-  public boolean hasServices()
+  @Override
+  public boolean testServiceUrl(URL url)
   {
-    return finished == true && services != null && services.size() > 0;
+    return getServerStatusFor(url.toString()) == STATUS_OK;
   }
 
-  public boolean isRunning()
+  @Override
+  public int getServerStatusFor(String url)
+  {
+    try
+    {
+      List<?> services = new SlivkaClient(url).getServices();
+      return services.isEmpty() ? STATUS_NO_SERVICES : STATUS_OK;
+    } catch (IOException e)
+    {
+      Cache.log.error("Slivka could not retrieve services list", e);
+      return STATUS_INVALID;
+    }
+  }
+
+  @Override
+  public String getErrorMessages()
   {
-    return discoverer != null && discoverer.isAlive();
+    // TODO Auto-generated method stub
+    return "";
   }
 }