Merge with update plugins feature

scm-webapp/src/main/java/sonia/scm/api/v2/resources/AvailablePluginResource.java

@@ -4,7 +4,7 @@ import com.webcohesion.enunciate.metadata.rs.ResponseCode;
 import com.webcohesion.enunciate.metadata.rs.StatusCodes;
 import com.webcohesion.enunciate.metadata.rs.TypeHint;
 import sonia.scm.plugin.AvailablePlugin;
-import sonia.scm.plugin.InstalledPluginDescriptor;
+import sonia.scm.plugin.InstalledPlugin;
 import sonia.scm.plugin.PluginManager;
 import sonia.scm.plugin.PluginPermissions;
 import sonia.scm.web.VndMediaType;
@@ -19,6 +19,7 @@ import javax.ws.rs.QueryParam;
 import javax.ws.rs.core.Response;
 import java.util.List;
 import java.util.Optional;
+import java.util.stream.Collectors;
 
 import static sonia.scm.ContextEntry.ContextBuilder.entity;
 import static sonia.scm.NotFoundException.notFound;
@@ -51,10 +52,15 @@ public class AvailablePluginResource {
   @Produces(VndMediaType.PLUGIN_COLLECTION)
   public Response getAvailablePlugins() {
     PluginPermissions.read().check();
-    List<AvailablePlugin> available = pluginManager.getAvailable();
+    List<InstalledPlugin> installed = pluginManager.getInstalled();
+    List<AvailablePlugin> available = pluginManager.getAvailable().stream().filter(a -> notInstalled(a, installed)).collect(Collectors.toList());
     return Response.ok(collectionMapper.mapAvailable(available)).build();
   }
 
+  private boolean notInstalled(AvailablePlugin a, List<InstalledPlugin> installed) {
+    return installed.stream().noneMatch(installedPlugin -> installedPlugin.getDescriptor().getInformation().getName().equals(a.getDescriptor().getInformation().getName()));
+  }
+
   /**
    * Returns available plugin.
    *
@@ -95,16 +101,4 @@ public class AvailablePluginResource {
     pluginManager.install(name, restartAfterInstallation);
     return Response.ok().build();
   }
-
-  @POST
-  @Path("/install-pending")
-  @StatusCodes({
-    @ResponseCode(code = 200, condition = "success"),
-    @ResponseCode(code = 500, condition = "internal server error")
-  })
-  public Response installPending() {
-    PluginPermissions.manage().check();
-    pluginManager.installPendingAndRestart();
-    return Response.ok().build();
-  }
 }

scm-webapp/src/main/java/sonia/scm/api/v2/resources/IndexDtoGenerator.java

@@ -54,6 +54,9 @@ public class IndexDtoGenerator extends HalAppenderMapper {
         builder.single(link("installedPlugins", resourceLinks.installedPluginCollection().self()));
         builder.single(link("availablePlugins", resourceLinks.availablePluginCollection().self()));
       }
+      if (PluginPermissions.manage().isPermitted()) {
+        builder.single(link("pendingPlugins", resourceLinks.pendingPluginCollection().self()));
+      }
       if (UserPermissions.list().isPermitted()) {
         builder.single(link("users", resourceLinks.userCollection().self()));
       }

scm-webapp/src/main/java/sonia/scm/api/v2/resources/InstalledPluginResource.java

@@ -3,8 +3,8 @@ package sonia.scm.api.v2.resources;
 import com.webcohesion.enunciate.metadata.rs.ResponseCode;
 import com.webcohesion.enunciate.metadata.rs.StatusCodes;
 import com.webcohesion.enunciate.metadata.rs.TypeHint;
+import sonia.scm.plugin.AvailablePlugin;
 import sonia.scm.plugin.InstalledPlugin;
-import sonia.scm.plugin.InstalledPluginDescriptor;
 import sonia.scm.plugin.PluginManager;
 import sonia.scm.plugin.PluginPermissions;
 import sonia.scm.web.VndMediaType;
@@ -50,7 +50,8 @@ public class InstalledPluginResource {
   public Response getInstalledPlugins() {
     PluginPermissions.read().check();
     List<InstalledPlugin> plugins = pluginManager.getInstalled();
-    return Response.ok(collectionMapper.mapInstalled(plugins)).build();
+    List<AvailablePlugin> available = pluginManager.getAvailable();
+    return Response.ok(collectionMapper.mapInstalled(plugins, available)).build();
   }
 
   /**
@@ -72,8 +73,9 @@ public class InstalledPluginResource {
   public Response getInstalledPlugin(@PathParam("name") String name) {
     PluginPermissions.read().check();
     Optional<InstalledPlugin> pluginDto = pluginManager.getInstalled(name);
+    List<AvailablePlugin> available = pluginManager.getAvailable();
     if (pluginDto.isPresent()) {
-      return Response.ok(mapper.mapInstalled(pluginDto.get())).build();
+      return Response.ok(mapper.mapInstalled(pluginDto.get(), available)).build();
     } else {
       throw notFound(entity("Plugin", name));
     }

scm-webapp/src/main/java/sonia/scm/api/v2/resources/PendingPluginResource.java

@@ -0,0 +1,105 @@
+package sonia.scm.api.v2.resources;
+
+import com.webcohesion.enunciate.metadata.rs.ResponseCode;
+import com.webcohesion.enunciate.metadata.rs.StatusCodes;
+import de.otto.edison.hal.Embedded;
+import de.otto.edison.hal.HalRepresentation;
+import de.otto.edison.hal.Links;
+import sonia.scm.plugin.AvailablePlugin;
+import sonia.scm.plugin.InstalledPlugin;
+import sonia.scm.plugin.PluginManager;
+import sonia.scm.plugin.PluginPermissions;
+import sonia.scm.web.VndMediaType;
+
+import javax.inject.Inject;
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.Produces;
+import javax.ws.rs.core.Response;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Stream;
+
+import static de.otto.edison.hal.Link.link;
+import static de.otto.edison.hal.Links.linkingTo;
+import static java.util.stream.Collectors.toList;
+
+public class PendingPluginResource {
+
+  private final PluginManager pluginManager;
+  private final ResourceLinks resourceLinks;
+  private final PluginDtoMapper mapper;
+
+  @Inject
+  public PendingPluginResource(PluginManager pluginManager, ResourceLinks resourceLinks, PluginDtoMapper mapper) {
+    this.pluginManager = pluginManager;
+    this.resourceLinks = resourceLinks;
+    this.mapper = mapper;
+  }
+
+  @GET
+  @Path("")
+  @StatusCodes({
+    @ResponseCode(code = 200, condition = "success"),
+    @ResponseCode(code = 500, condition = "internal server error")
+  })
+  @Produces(VndMediaType.PLUGIN_COLLECTION)
+  public Response getPending() {
+    PluginPermissions.manage().check();
+
+    List<AvailablePlugin> pending = pluginManager
+      .getAvailable()
+      .stream()
+      .filter(AvailablePlugin::isPending)
+      .collect(toList());
+    List<InstalledPlugin> installed = pluginManager.getInstalled();
+
+    Stream<AvailablePlugin> newPlugins = pending
+      .stream()
+      .filter(a -> !contains(installed, a));
+    Stream<InstalledPlugin> updatePlugins = installed
+      .stream()
+      .filter(i -> contains(pending, i));
+
+    Links.Builder linksBuilder = linkingTo().self(resourceLinks.pendingPluginCollection().self());
+
+    if (!pending.isEmpty()) {
+      linksBuilder.single(link("install", resourceLinks.pendingPluginCollection().installPending()));
+    }
+
+    Embedded.Builder embedded = Embedded.embeddedBuilder();
+    embedded.with("new", newPlugins.map(mapper::mapAvailable).collect(toList()));
+    embedded.with("update", updatePlugins.map(i -> mapper.mapInstalled(i, pending)).collect(toList()));
+
+    return Response.ok(new HalRepresentation(linksBuilder.build(), embedded.build())).build();
+  }
+
+  private boolean contains(Collection<InstalledPlugin> installedPlugins, AvailablePlugin availablePlugin) {
+    return installedPlugins
+      .stream()
+      .anyMatch(installedPlugin -> haveSameName(installedPlugin, availablePlugin));
+  }
+
+  private boolean contains(Collection<AvailablePlugin> availablePlugins, InstalledPlugin installedPlugin) {
+    return availablePlugins
+      .stream()
+      .anyMatch(availablePlugin -> haveSameName(installedPlugin, availablePlugin));
+  }
+
+  private boolean haveSameName(InstalledPlugin installedPlugin, AvailablePlugin availablePlugin) {
+    return installedPlugin.getDescriptor().getInformation().getName().equals(availablePlugin.getDescriptor().getInformation().getName());
+  }
+
+  @POST
+  @Path("/install")
+  @StatusCodes({
+    @ResponseCode(code = 200, condition = "success"),
+    @ResponseCode(code = 500, condition = "internal server error")
+  })
+  public Response installPending() {
+    PluginPermissions.manage().check();
+    pluginManager.installPendingAndRestart();
+    return Response.ok().build();
+  }
+}

scm-webapp/src/main/java/sonia/scm/api/v2/resources/PluginDto.java

@@ -1,5 +1,6 @@
 package sonia.scm.api.v2.resources;
 
+import com.fasterxml.jackson.annotation.JsonInclude;
 import de.otto.edison.hal.HalRepresentation;
 import de.otto.edison.hal.Links;
 import lombok.Getter;
@@ -16,12 +17,16 @@ public class PluginDto extends HalRepresentation {
 
   private String name;
   private String version;
+  @JsonInclude(JsonInclude.Include.NON_NULL)
+  private String newVersion;
   private String displayName;
   private String description;
   private String author;
   private String category;
   private String avatarUrl;
   private boolean pending;
+  @JsonInclude(JsonInclude.Include.NON_NULL)
+  private Boolean core;
   private Set<String> dependencies;
 
   public PluginDto(Links links) {

scm-webapp/src/main/java/sonia/scm/api/v2/resources/PluginDtoCollectionMapper.java

@@ -26,8 +26,11 @@ public class PluginDtoCollectionMapper {
     this.mapper = mapper;
   }
 
-  public HalRepresentation mapInstalled(List<InstalledPlugin> plugins) {
-    List<PluginDto> dtos = plugins.stream().map(mapper::mapInstalled).collect(toList());
+  public HalRepresentation mapInstalled(List<InstalledPlugin> plugins, List<AvailablePlugin> availablePlugins) {
+    List<PluginDto> dtos = plugins
+      .stream()
+      .map(i -> mapper.mapInstalled(i, availablePlugins))
+      .collect(toList());
     return new HalRepresentation(createInstalledPluginsLinks(), embedDtos(dtos));
   }
 
@@ -50,10 +53,6 @@ public class PluginDtoCollectionMapper {
     Links.Builder linksBuilder = linkingTo()
       .with(Links.linkingTo().self(baseUrl).build());
 
-    if (PluginPermissions.manage().isPermitted() && containsPending(plugins)) {
-      linksBuilder.single(Link.link("installPending", resourceLinks.availablePluginCollection().installPending()));
-    }
-
     return linksBuilder.build();
   }
 

scm-webapp/src/main/java/sonia/scm/api/v2/resources/PluginDtoMapper.java

@@ -11,6 +11,9 @@ import sonia.scm.plugin.PluginPermissions;
 
 import javax.inject.Inject;
 
+import java.util.List;
+import java.util.Optional;
+
 import static de.otto.edison.hal.Link.link;
 import static de.otto.edison.hal.Links.linkingTo;
 
@@ -22,8 +25,8 @@ public abstract class PluginDtoMapper {
 
   public abstract void map(PluginInformation plugin, @MappingTarget PluginDto dto);
 
-  public PluginDto mapInstalled(InstalledPlugin plugin) {
-    PluginDto dto = createDtoForInstalled(plugin);
+  public PluginDto mapInstalled(InstalledPlugin plugin, List<AvailablePlugin> availablePlugins) {
+    PluginDto dto = createDtoForInstalled(plugin, availablePlugins);
     map(dto, plugin);
     return dto;
   }
@@ -57,13 +60,36 @@ public abstract class PluginDtoMapper {
     return new PluginDto(links.build());
   }
 
-  private PluginDto createDtoForInstalled(InstalledPlugin plugin) {
+  private PluginDto createDtoForInstalled(InstalledPlugin plugin, List<AvailablePlugin> availablePlugins) {
     PluginInformation information = plugin.getDescriptor().getInformation();
+    Optional<AvailablePlugin> availablePlugin = checkForUpdates(plugin, availablePlugins);
 
     Links.Builder links = linkingTo()
       .self(resourceLinks.installedPlugin()
         .self(information.getName()));
+    if (!plugin.isCore()
+      && availablePlugin.isPresent()
+      && !availablePlugin.get().isPending()
+      && PluginPermissions.manage().isPermitted()
+    ) {
+      links.single(link("update", resourceLinks.availablePlugin().install(information.getName())));
+    }
 
-    return new PluginDto(links.build());
+    PluginDto dto = new PluginDto(links.build());
+
+    availablePlugin.ifPresent(value -> {
+      dto.setNewVersion(value.getDescriptor().getInformation().getVersion());
+      dto.setPending(value.isPending());
+    });
+
+    dto.setCore(plugin.isCore());
+
+    return dto;
+  }
+
+  private Optional<AvailablePlugin> checkForUpdates(InstalledPlugin plugin, List<AvailablePlugin> availablePlugins) {
+    return availablePlugins.stream()
+      .filter(a -> a.getDescriptor().getInformation().getName().equals(plugin.getDescriptor().getInformation().getName()))
+      .findAny();
   }
 }

scm-webapp/src/main/java/sonia/scm/api/v2/resources/PluginRootResource.java

@@ -9,11 +9,13 @@ public class PluginRootResource {
 
   private Provider<InstalledPluginResource> installedPluginResourceProvider;
   private Provider<AvailablePluginResource> availablePluginResourceProvider;
+  private Provider<PendingPluginResource> pendingPluginResourceProvider;
 
   @Inject
-  public PluginRootResource(Provider<InstalledPluginResource> installedPluginResourceProvider, Provider<AvailablePluginResource> availablePluginResourceProvider) {
+  public PluginRootResource(Provider<InstalledPluginResource> installedPluginResourceProvider, Provider<AvailablePluginResource> availablePluginResourceProvider, Provider<PendingPluginResource> pendingPluginResourceProvider) {
     this.installedPluginResourceProvider = installedPluginResourceProvider;
     this.availablePluginResourceProvider = availablePluginResourceProvider;
+    this.pendingPluginResourceProvider = pendingPluginResourceProvider;
   }
 
   @Path("/installed")
@@ -23,4 +25,7 @@ public class PluginRootResource {
 
   @Path("/available")
   public AvailablePluginResource availablePlugins() { return availablePluginResourceProvider.get(); }
+
+  @Path("/pending")
+  public PendingPluginResource pendingPlugins() { return pendingPluginResourceProvider.get(); }
 }

scm-webapp/src/main/java/sonia/scm/api/v2/resources/ResourceLinks.java

@@ -715,12 +715,28 @@ class ResourceLinks {
       availablePluginCollectionLinkBuilder = new LinkBuilder(pathInfo, PluginRootResource.class, AvailablePluginResource.class);
     }
 
+    String self() {
+      return availablePluginCollectionLinkBuilder.method("availablePlugins").parameters().method("getAvailablePlugins").parameters().href();
+    }
+  }
+
+  public PendingPluginCollectionLinks pendingPluginCollection() {
+    return new PendingPluginCollectionLinks(scmPathInfoStore.get());
+  }
+
+  static class PendingPluginCollectionLinks {
+    private final LinkBuilder pendingPluginCollectionLinkBuilder;
+
+    PendingPluginCollectionLinks(ScmPathInfo pathInfo) {
+      pendingPluginCollectionLinkBuilder = new LinkBuilder(pathInfo, PluginRootResource.class, PendingPluginResource.class);
+    }
+
     String installPending() {
-      return availablePluginCollectionLinkBuilder.method("availablePlugins").parameters().method("installPending").parameters().href();
+      return pendingPluginCollectionLinkBuilder.method("pendingPlugins").parameters().method("installPending").parameters().href();
     }
 
     String self() {
-      return availablePluginCollectionLinkBuilder.method("availablePlugins").parameters().method("getAvailablePlugins").parameters().href();
+      return pendingPluginCollectionLinkBuilder.method("pendingPlugins").parameters().method("getPending").parameters().href();
     }
   }
 

scm-webapp/src/main/java/sonia/scm/plugin/DefaultPluginManager.java

@@ -39,8 +39,10 @@ import com.google.inject.Singleton;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import sonia.scm.NotFoundException;
+import sonia.scm.ScmConstraintViolationException;
 import sonia.scm.event.ScmEventBus;
 import sonia.scm.lifecycle.RestartEvent;
+import sonia.scm.version.Version;
 
 import javax.inject.Inject;
 import java.io.IOException;
@@ -54,6 +56,7 @@ import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
 import static sonia.scm.ContextEntry.ContextBuilder.entity;
+import static sonia.scm.ScmConstraintViolationException.Builder.doThrow;
 
 //~--- JDK imports ------------------------------------------------------------
 
@@ -97,7 +100,7 @@ public class DefaultPluginManager implements PluginManager {
     return center.getAvailable()
       .stream()
       .filter(filterByName(name))
-      .filter(this::isNotInstalled)
+      .filter(this::isNotInstalledOrMoreUpToDate)
       .map(p -> getPending(name).orElse(p))
       .findFirst();
   }
@@ -130,7 +133,7 @@ public class DefaultPluginManager implements PluginManager {
     PluginPermissions.read().check();
     return center.getAvailable()
       .stream()
-      .filter(this::isNotInstalled)
+      .filter(this::isNotInstalledOrMoreUpToDate)
       .map(p -> getPending(p.getDescriptor().getInformation().getName()).orElse(p))
       .collect(Collectors.toList());
   }
@@ -139,13 +142,26 @@ public class DefaultPluginManager implements PluginManager {
     return plugin -> name.equals(plugin.getDescriptor().getInformation().getName());
   }
 
-  private boolean isNotInstalled(AvailablePlugin availablePlugin) {
-    return !getInstalled(availablePlugin.getDescriptor().getInformation().getName()).isPresent();
+  private boolean isNotInstalledOrMoreUpToDate(AvailablePlugin availablePlugin) {
+    return getInstalled(availablePlugin.getDescriptor().getInformation().getName())
+      .map(installedPlugin -> availableIsMoreUpToDateThanInstalled(availablePlugin, installedPlugin))
+      .orElse(true);
+  }
+
+  private boolean availableIsMoreUpToDateThanInstalled(AvailablePlugin availablePlugin, InstalledPlugin installed) {
+    return Version.parse(availablePlugin.getDescriptor().getInformation().getVersion()).isNewer(installed.getDescriptor().getInformation().getVersion());
   }
 
   @Override
   public void install(String name, boolean restartAfterInstallation) {
     PluginPermissions.manage().check();
+
+    getInstalled(name)
+      .map(InstalledPlugin::isCore)
+      .ifPresent(
+        core -> doThrow().violation("plugin is a core plugin and cannot be updated").when(core)
+      );
+
     List<AvailablePlugin> plugins = collectPluginsToInstall(name);
     List<PendingPluginInstallation> pendingInstallations = new ArrayList<>();
     for (AvailablePlugin plugin : plugins) {
@@ -200,22 +216,18 @@ public class DefaultPluginManager implements PluginManager {
 
   private List<AvailablePlugin> collectPluginsToInstall(String name) {
     List<AvailablePlugin> plugins = new ArrayList<>();
-    collectPluginsToInstall(plugins, name);
+    collectPluginsToInstall(plugins, name, true);
     return plugins;
   }
 
-  private boolean isInstalledOrPending(String name) {
-    return getInstalled(name).isPresent() || getPending(name).isPresent();
-  }
-
-  private void collectPluginsToInstall(List<AvailablePlugin> plugins, String name) {
-    if (!isInstalledOrPending(name)) {
+  private void collectPluginsToInstall(List<AvailablePlugin> plugins, String name, boolean isUpdate) {
+    if (!isInstalledOrPending(name) || isUpdate && isUpdatable(name)) {
       AvailablePlugin plugin = getAvailable(name).orElseThrow(() -> NotFoundException.notFound(entity(AvailablePlugin.class, name)));
 
       Set<String> dependencies = plugin.getDescriptor().getDependencies();
       if (dependencies != null) {
         for (String dependency: dependencies){
-          collectPluginsToInstall(plugins, dependency);
+          collectPluginsToInstall(plugins, dependency, false);
         }
       }
 
@@ -224,4 +236,12 @@ public class DefaultPluginManager implements PluginManager {
       LOG.info("plugin {} is already installed or installation is pending, skipping installation", name);
     }
   }
+
+  private boolean isInstalledOrPending(String name) {
+    return getInstalled(name).isPresent() || getPending(name).isPresent();
+  }
+
+  private boolean isUpdatable(String name) {
+    return getAvailable(name).isPresent() && !getPending(name).isPresent();
+  }
 }

scm-webapp/src/main/java/sonia/scm/plugin/PluginProcessor.java

@@ -461,13 +461,16 @@ public final class PluginProcessor
     Path descriptorPath = directory.resolve(PluginConstants.FILE_DESCRIPTOR);
 
     if (Files.exists(descriptorPath)) {
+
+      boolean core = Files.exists(directory.resolve("core"));
+
       ClassLoader cl = createClassLoader(classLoader, smp);
 
       InstalledPluginDescriptor descriptor = createDescriptor(cl, descriptorPath);
 
       WebResourceLoader resourceLoader = createWebResourceLoader(directory);
 
-      plugin = new InstalledPlugin(descriptor, cl, resourceLoader, directory);
+      plugin = new InstalledPlugin(descriptor, cl, resourceLoader, directory, core);
     } else {
       logger.warn("found plugin directory without plugin descriptor");
     }