Nemcio/SCM-Manager
1
0
Fork 0
mirror of https://github.com/scm-manager/scm-manager.git synced 2025-11-13 00:45:44 +01:00
Code Issues Packages Projects Releases Activity

create new simplified PluginManager API

Browse Source
This commit is contained in:
Sebastian Sdorra
2019-08-20 10:33:57 +02:00
parent 0aaec1174a
commit 3f1521bcca
19 changed files with 220 additions and 1410 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -3,11 +3,10 @@ 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.InstalledPluginDescriptor;
import sonia.scm.plugin.PluginInformation;
import sonia.scm.plugin.PluginManager;
import sonia.scm.plugin.PluginPermissions;
import sonia.scm.plugin.PluginState;
import sonia.scm.web.VndMediaType;
import javax.inject.Inject;
@@ -18,9 +17,8 @@ import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.Response;
import java.util.Collection;
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;
@@ -53,11 +51,8 @@ public class AvailablePluginResource {
@Produces(VndMediaType.PLUGIN_COLLECTION)
public Response getAvailablePlugins() {
PluginPermissions.read().check();
Collection<PluginInformation> plugins = pluginManager.getAvailable()
.stream()
.filter(plugin -> plugin.getState().equals(PluginState.AVAILABLE))
.collect(Collectors.toList());
return Response.ok(collectionMapper.map(plugins)).build();
List<AvailablePlugin> available = pluginManager.getAvailable();
return Response.ok(collectionMapper.mapAvailable(available)).build();
}
/**
@@ -66,7 +61,7 @@ public class AvailablePluginResource {
* @return available plugin.
*/
@GET
@Path("/{name}/{version}")
@Path("/{name}")
@StatusCodes({
@ResponseCode(code = 200, condition = "success"),
@ResponseCode(code = 404, condition = "not found"),
@@ -74,12 +69,9 @@ public class AvailablePluginResource {
})
@TypeHint(PluginDto.class)
@Produces(VndMediaType.PLUGIN)
public Response getAvailablePlugin(@PathParam("name") String name, @PathParam("version") String version) {
public Response getAvailablePlugin(@PathParam("name") String name) {
PluginPermissions.read().check();
Optional<PluginInformation> plugin = pluginManager.getAvailable()
.stream()
.filter(p -> p.getId().equals(name + ":" + version))
.findFirst();
Optional<AvailablePlugin> plugin = pluginManager.getAvailable(name);
if (plugin.isPresent()) {
return Response.ok(mapper.map(plugin.get())).build();
} else {
@@ -90,19 +82,18 @@ public class AvailablePluginResource {
/**
* Triggers plugin installation.
* @param name plugin artefact name
* @param version plugin version
* @return HTTP Status.
*/
@POST
@Path("/{name}/{version}/install")
@Path("/{name}/install")
@Consumes(VndMediaType.PLUGIN)
@StatusCodes({
@ResponseCode(code = 200, condition = "success"),
@ResponseCode(code = 500, condition = "internal server error")
})
public Response installPlugin(@PathParam("name") String name, @PathParam("version") String version) {
public Response installPlugin(@PathParam("name") String name) {
PluginPermissions.manage().check();
pluginManager.install(name + ":" + version);
pluginManager.install(name);
return Response.ok().build();
}
}

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

@@ -3,11 +3,10 @@ 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.InstalledPlugin;
import sonia.scm.plugin.InstalledPluginDescriptor;
import sonia.scm.plugin.PluginLoader;
import sonia.scm.plugin.PluginManager;
import sonia.scm.plugin.PluginPermissions;
import sonia.scm.plugin.InstalledPlugin;
import sonia.scm.web.VndMediaType;
import javax.inject.Inject;
@@ -16,7 +15,6 @@ import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.Response;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
@@ -25,17 +23,15 @@ import static sonia.scm.NotFoundException.notFound;
public class InstalledPluginResource {
private final PluginLoader pluginLoader;
private final PluginDtoCollectionMapper collectionMapper;
private final PluginDtoMapper mapper;
private final PluginManager pluginManager;
@Inject
public InstalledPluginResource(PluginLoader pluginLoader, PluginDtoCollectionMapper collectionMapper, PluginDtoMapper mapper, PluginManager pluginManager) {
this.pluginLoader = pluginLoader;
public InstalledPluginResource(PluginManager pluginManager, PluginDtoCollectionMapper collectionMapper, PluginDtoMapper mapper) {
this.pluginManager = pluginManager;
this.collectionMapper = collectionMapper;
this.mapper = mapper;
this.pluginManager = pluginManager;
}
/**
@@ -53,8 +49,8 @@ public class InstalledPluginResource {
@Produces(VndMediaType.PLUGIN_COLLECTION)
public Response getInstalledPlugins() {
PluginPermissions.read().check();
List<InstalledPlugin> plugins = new ArrayList<>(pluginLoader.getInstalledPlugins());
return Response.ok(collectionMapper.map(plugins)).build();
List<InstalledPlugin> plugins = pluginManager.getInstalled();
return Response.ok(collectionMapper.mapInstalled(plugins)).build();
}
/**
@@ -75,13 +71,9 @@ public class InstalledPluginResource {
@Produces(VndMediaType.PLUGIN)
public Response getInstalledPlugin(@PathParam("name") String name) {
PluginPermissions.read().check();
Optional<PluginDto> pluginDto = pluginLoader.getInstalledPlugins()
.stream()
.filter(plugin -> name.equals(plugin.getDescriptor().getInformation().getName()))
.map(mapper::map)
.findFirst();
Optional<InstalledPlugin> pluginDto = pluginManager.getInstalled(name);
if (pluginDto.isPresent()) {
return Response.ok(pluginDto.get()).build();
return Response.ok(mapper.map(pluginDto.get())).build();
} else {
throw notFound(entity(InstalledPluginDescriptor.class, name));
}

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

@@ -4,6 +4,7 @@ import com.google.inject.Inject;
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.PluginInformation;
import sonia.scm.plugin.InstalledPlugin;
@@ -25,12 +26,12 @@ public class PluginDtoCollectionMapper {
this.mapper = mapper;
}
public HalRepresentation map(List<InstalledPlugin> plugins) {
public HalRepresentation mapInstalled(List<InstalledPlugin> plugins) {
List<PluginDto> dtos = plugins.stream().map(mapper::map).collect(toList());
return new HalRepresentation(createInstalledPluginsLinks(), embedDtos(dtos));
}
public HalRepresentation map(Collection<PluginInformation> plugins) {
public HalRepresentation mapAvailable(List<AvailablePlugin> plugins) {
List<PluginDto> dtos = plugins.stream().map(mapper::map).collect(toList());
return new HalRepresentation(createAvailablePluginsLinks(), embedDtos(dtos));
}

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

@@ -1,13 +1,11 @@
package sonia.scm.api.v2.resources;
import de.otto.edison.hal.Links;
import org.mapstruct.AfterMapping;
import org.mapstruct.Mapper;
import org.mapstruct.MappingTarget;
import org.mapstruct.ObjectFactory;
import sonia.scm.plugin.Plugin;
import sonia.scm.plugin.PluginInformation;
import sonia.scm.plugin.PluginState;
import sonia.scm.plugin.InstalledPlugin;
import javax.inject.Inject;
@@ -20,23 +18,23 @@ public abstract class PluginDtoMapper {
@Inject
private ResourceLinks resourceLinks;
public PluginDto map(InstalledPlugin plugin) {
return map(plugin.getDescriptor().getInformation());
}
public abstract void map(PluginInformation plugin, @MappingTarget PluginDto dto);
public abstract PluginDto map(PluginInformation plugin);
@AfterMapping
protected void appendCategory(@MappingTarget PluginDto dto) {
public PluginDto map(Plugin plugin) {
PluginDto dto = createDto(plugin);
map(plugin.getDescriptor().getInformation(), dto);
if (dto.getCategory() == null) {
dto.setCategory("Miscellaneous");
}
return dto;
}
@ObjectFactory
public PluginDto createDto(PluginInformation pluginInformation) {
private PluginDto createDto(Plugin plugin) {
Links.Builder linksBuilder;
if (pluginInformation.getState() != null && pluginInformation.getState().equals(PluginState.AVAILABLE)) {
PluginInformation pluginInformation = plugin.getDescriptor().getInformation();
if (plugin.getState() != null && plugin.getState().equals(PluginState.AVAILABLE)) {
linksBuilder = linkingTo()
.self(resourceLinks.availablePlugin()
.self(pluginInformation.getName(), pluginInformation.getVersion()));

668
scm-webapp/src/main/java/sonia/scm/plugin/DefaultPluginManager.java
View File

@@ -35,685 +35,41 @@ package sonia.scm.plugin;
//~--- non-JDK imports --------------------------------------------------------
import com.github.legman.Subscribe;
import com.google.common.base.Predicate;
import com.google.common.io.Files;
import com.google.inject.Inject;
import com.google.inject.Singleton;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import sonia.scm.SCMContextProvider;
import sonia.scm.cache.Cache;
import sonia.scm.cache.CacheManager;
import sonia.scm.config.ScmConfiguration;
import sonia.scm.config.ScmConfigurationChangedEvent;
import sonia.scm.io.ZipUnArchiver;
import sonia.scm.util.AssertUtil;
import sonia.scm.util.IOUtil;
import sonia.scm.util.SystemUtil;
import sonia.scm.util.Util;
import sonia.scm.version.Version;
//~--- JDK imports ------------------------------------------------------------
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;
import javax.xml.bind.JAXB;
import sonia.scm.net.ahc.AdvancedHttpClient;
import static sonia.scm.plugin.PluginCenterDtoMapper.*;
import java.util.List;
import java.util.Optional;
/**
* TODO replace aether stuff.
* TODO check AdvancedPluginConfiguration from 1.x
*
* @author Sebastian Sdorra
*/
@Singleton
public class DefaultPluginManager implements PluginManager
{
public class DefaultPluginManager implements PluginManager {
/** Field description */
public static final String CACHE_NAME = "sonia.cache.plugins";
/** Field description */
public static final String ENCODING = "UTF-8";
/** the logger for DefaultPluginManager */
private static final Logger logger =
LoggerFactory.getLogger(DefaultPluginManager.class);
/** enable or disable remote plugins */
private static final boolean REMOTE_PLUGINS_ENABLED = true;
/** Field description */
public static final Predicate<PluginInformation> FILTER_UPDATES =
new StatePluginPredicate(PluginState.UPDATE_AVAILABLE);
//~--- constructors ---------------------------------------------------------
/**
* Constructs ...
*
* @param context
* @param configuration
* @param pluginLoader
* @param cacheManager
* @param httpClient
*/
@Inject
public DefaultPluginManager(SCMContextProvider context,
ScmConfiguration configuration, PluginLoader pluginLoader,
CacheManager cacheManager, AdvancedHttpClient httpClient)
{
this.context = context;
this.configuration = configuration;
this.cache = cacheManager.getCache(CACHE_NAME);
this.httpClient = httpClient;
installedPlugins = new HashMap<>();
for (InstalledPlugin wrapper : pluginLoader.getInstalledPlugins())
{
InstalledPluginDescriptor plugin = wrapper.getDescriptor();
PluginInformation info = plugin.getInformation();
if ((info != null) && info.isValid())
{
installedPlugins.put(info.getId(), plugin);
}
}
}
//~--- methods --------------------------------------------------------------
/**
* Method description
*
*/
@Override
public void clearCache()
{
if (logger.isDebugEnabled())
{
logger.debug("clear plugin cache");
}
cache.clear();
public Optional<AvailablePlugin> getAvailable(String name) {
return Optional.empty();
}
/**
* Method description
*
*
* @param config
*/
@Subscribe
public void configChanged(ScmConfigurationChangedEvent config)
{
clearCache();
}
/**
* Method description
*
*
* @param id
*/
@Override
public void install(String id)
{
PluginPermissions.manage().check();
PluginCenter center = getPluginCenter();
for (PluginInformation plugin : center.getPlugins())
{
String pluginId = plugin.getId();
if (Util.isNotEmpty(pluginId) && pluginId.equals(id))
{
plugin.setState(PluginState.INSTALLED);
// ugly workaround
InstalledPluginDescriptor newPlugin = new InstalledPluginDescriptor();
// TODO check
// newPlugin.setInformation(plugin);
installedPlugins.put(id, newPlugin);
}
}
public Optional<InstalledPlugin> getInstalled(String name) {
return Optional.empty();
}
/**
* Method description
*
*
* @param packageStream
*
* @throws IOException
*/
@Override
public void installPackage(InputStream packageStream) throws IOException
{
PluginPermissions.manage().check();
File tempDirectory = Files.createTempDir();
try
{
new ZipUnArchiver().extractArchive(packageStream, tempDirectory);
InstalledPluginDescriptor plugin = JAXB.unmarshal(new File(tempDirectory, "plugin.xml"),
InstalledPluginDescriptor.class);
PluginCondition condition = plugin.getCondition();
if ((condition != null) &&!condition.isSupported())
{
throw new PluginConditionFailedException(condition);
}
/*
* AetherPluginHandler aph = new AetherPluginHandler(this, context,
* configuration);
* Collection<PluginRepository> repositories =
* Sets.newHashSet(new PluginRepository("package-repository",
* "file://".concat(tempDirectory.getAbsolutePath())));
*
* aph.setPluginRepositories(repositories);
*
* aph.install(plugin.getInformation().getId());
*/
plugin.getInformation().setState(PluginState.INSTALLED);
installedPlugins.put(plugin.getInformation().getId(), plugin);
}
finally
{
IOUtil.delete(tempDirectory);
}
public List<InstalledPlugin> getInstalled() {
return null;
}
/**
* Method description
*
*
* @param id
*/
@Override
public void uninstall(String id)
{
PluginPermissions.manage().check();
InstalledPluginDescriptor plugin = installedPlugins.get(id);
if (plugin == null)
{
String pluginPrefix = getPluginIdPrefix(id);
for (String nid : installedPlugins.keySet())
{
if (nid.startsWith(pluginPrefix))
{
id = nid;
plugin = installedPlugins.get(nid);
break;
}
}
}
if (plugin == null)
{
throw new PluginNotInstalledException(id.concat(" is not install"));
}
/*
* if (pluginHandler == null)
* {
* getPluginCenter();
* }
*
* pluginHandler.uninstall(id);
*/
installedPlugins.remove(id);
preparePlugins(getPluginCenter());
public List<AvailablePlugin> getAvailable() {
return null;
}
/**
* Method description
*
*
* @param id
*/
@Override
public void update(String id)
{
PluginPermissions.manage().check();
public void install(String name) {
String[] idParts = id.split(":");
String name = idParts[0];
PluginInformation installed = null;
for (PluginInformation info : getInstalled())
{
if (name.equals(info.getName()))
{
installed = info;
break;
}
}
if (installed == null)
{
StringBuilder msg = new StringBuilder(name);
msg.append(" is not install");
throw new PluginNotInstalledException(msg.toString());
}
uninstall(installed.getId());
install(id);
}
//~--- get methods ----------------------------------------------------------
/**
* Method description
*
*
* @param id
*
* @return
*/
@Override
public PluginInformation get(String id)
{
PluginPermissions.read().check();
PluginInformation result = null;
for (PluginInformation info : getPluginCenter().getPlugins())
{
if (id.equals(info.getId()))
{
result = info;
break;
}
}
return result;
}
/**
* Method description
*
*
* @param predicate
*
* @return
*/
@Override
public Set<PluginInformation> get(Predicate<PluginInformation> predicate)
{
AssertUtil.assertIsNotNull(predicate);
PluginPermissions.read().check();
Set<PluginInformation> infoSet = new HashSet<>();
filter(infoSet, getInstalled(), predicate);
filter(infoSet, getPluginCenter().getPlugins(), predicate);
return infoSet;
}
/**
* Method description
*
*
* @return
*/
@Override
public Collection<PluginInformation> getAll()
{
PluginPermissions.read().check();
Set<PluginInformation> infoSet = getInstalled();
infoSet.addAll(getPluginCenter().getPlugins());
return infoSet;
}
/**
* Method description
*
*
* @return
*/
@Override
public Collection<PluginInformation> getAvailable()
{
PluginPermissions.read().check();
Set<PluginInformation> availablePlugins = new HashSet<>();
Set<PluginInformation> centerPlugins = getPluginCenter().getPlugins();
for (PluginInformation info : centerPlugins)
{
if (!installedPlugins.containsKey(info.getName()))
{
availablePlugins.add(info);
}
}
return availablePlugins;
}
/**
* Method description
*
*
* @return
*/
@Override
public Set<PluginInformation> getAvailableUpdates()
{
PluginPermissions.read().check();
return get(FILTER_UPDATES);
}
/**
* Method description
*
*
* @return
*/
@Override
public Set<PluginInformation> getInstalled()
{
PluginPermissions.read().check();
Set<PluginInformation> infoSet = new LinkedHashSet<>();
for (InstalledPluginDescriptor plugin : installedPlugins.values())
{
infoSet.add(plugin.getInformation());
}
return infoSet;
}
//~--- methods --------------------------------------------------------------
/**
* Method description
*
*
*
* @param url
* @return
*/
private String buildPluginUrl(String url)
{
String os = SystemUtil.getOS();
String arch = SystemUtil.getArch();
try
{
os = URLEncoder.encode(os, ENCODING);
}
catch (UnsupportedEncodingException ex)
{
logger.error(ex.getMessage(), ex);
}
return url.replace("{version}", context.getVersion()).replace("{os}",
os).replace("{arch}", arch);
}
/**
* Method description
*
*
* @param target
* @param source
* @param predicate
*/
private void filter(Set<PluginInformation> target,
Collection<PluginInformation> source,
Predicate<PluginInformation> predicate)
{
for (PluginInformation info : source)
{
if (predicate.apply(info))
{
target.add(info);
}
}
}
/**
* Method description
*
*
* @param available
*/
private void preparePlugin(PluginInformation available)
{
PluginState state = PluginState.AVAILABLE;
for (PluginInformation installed : getInstalled())
{
if (isSamePlugin(available, installed))
{
if (installed.getVersion().equals(available.getVersion()))
{
state = PluginState.INSTALLED;
}
else if (isNewer(available, installed))
{
state = PluginState.UPDATE_AVAILABLE;
}
else
{
state = PluginState.NEWER_VERSION_INSTALLED;
}
break;
}
}
available.setState(state);
}
/**
* Method description
*
*
* @param pc
*/
private void preparePlugins(PluginCenter pc)
{
Set<PluginInformation> infoSet = pc.getPlugins();
if (infoSet != null)
{
Iterator<PluginInformation> pit = infoSet.iterator();
while (pit.hasNext())
{
PluginInformation available = pit.next();
if (isCorePluging(available))
{
pit.remove();
}
else
{
preparePlugin(available);
}
}
}
}
//~--- get methods ----------------------------------------------------------
/**
* Method description
*
*
* @return
*/
private PluginCenter getPluginCenter()
{
PluginCenter center = cache.get(PluginCenter.class.getName());
if (center == null)
{
synchronized (DefaultPluginManager.class)
{
String pluginUrl = buildPluginUrl(configuration.getPluginUrl());
logger.info("fetch plugin information from {}", pluginUrl);
if (REMOTE_PLUGINS_ENABLED && Util.isNotEmpty(pluginUrl))
{
try
{
center = new PluginCenter();
PluginCenterDto pluginCenterDto = httpClient.get(pluginUrl).request().contentFromJson(PluginCenterDto.class);
Set<PluginInformation> pluginInformationSet = map(pluginCenterDto.getEmbedded().getPlugins());
center.setPlugins(pluginInformationSet);
preparePlugins(center);
cache.put(PluginCenter.class.getName(), center);
}
catch (IOException ex)
{
logger.error("could not load plugins from plugin center", ex);
}
}
}
if(center == null) {
center = new PluginCenter();
}
}
return center;
}
/**
* Method description
*
*
* @param pluginId
*
* @return
*/
private String getPluginIdPrefix(String pluginId)
{
return pluginId.substring(0, pluginId.lastIndexOf(':'));
}
/**
* Method description
*
*
* @param available
*
* @return
*/
private boolean isCorePluging(PluginInformation available)
{
boolean core = false;
for (InstalledPluginDescriptor installedPlugin : installedPlugins.values())
{
PluginInformation installed = installedPlugin.getInformation();
if (isSamePlugin(available, installed)
&& (installed.getState() == PluginState.CORE))
{
core = true;
break;
}
}
return core;
}
/**
* Method description
*
*
* @param available
* @param installed
*
* @return
*/
private boolean isNewer(PluginInformation available,
PluginInformation installed)
{
boolean result = false;
Version version = Version.parse(available.getVersion());
if (version != null)
{
result = version.isNewer(installed.getVersion());
}
return result;
}
/**
* Method description
*
*
* @param p1
* @param p2
*
* @return
*/
private boolean isSamePlugin(PluginInformation p1, PluginInformation p2)
{
return p1.getName().equals(p2.getName());
}
//~--- fields ---------------------------------------------------------------
/** Field description */
private final Cache<String, PluginCenter> cache;
/** Field description */
private final AdvancedHttpClient httpClient;
/** Field description */
private final ScmConfiguration configuration;
/** Field description */
private final SCMContextProvider context;
/** Field description */
private final Map<String, InstalledPluginDescriptor> installedPlugins;
}

64
scm-webapp/src/main/java/sonia/scm/plugin/OverviewPluginPredicate.java
View File

@@ -1,64 +0,0 @@
/**
* Copyright (c) 2010, Sebastian Sdorra
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. Neither the name of SCM-Manager; nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* http://bitbucket.org/sdorra/scm-manager
*
*/
package sonia.scm.plugin;
import com.google.common.base.Predicate;
/**
*
* @author Sebastian Sdorra
*/
public class OverviewPluginPredicate implements Predicate<PluginInformation>
{
/** Field description */
public static final OverviewPluginPredicate INSTANCE =
new OverviewPluginPredicate();
//~--- methods --------------------------------------------------------------
/**
* Method description
*
*
* @param plugin
*
* @return
*/
@Override
public boolean apply(PluginInformation plugin)
{
return plugin.getState() != PluginState.NEWER_VERSION_INSTALLED;
}
}

67
scm-webapp/src/main/java/sonia/scm/plugin/PluginProcessor.java
View File

@@ -237,7 +237,7 @@ public final class PluginProcessor
}
InstalledPlugin plugin =
createPluginWrapper(createParentPluginClassLoader(classLoader, parents),
createPlugin(createParentPluginClassLoader(classLoader, parents),
smp);
if (plugin != null)
@@ -431,73 +431,36 @@ public final class PluginProcessor
return result;
}
/**
* Method description
*
*
*
* @param classLoader
* @param descriptor
*
* @return
*/
private InstalledPluginDescriptor createPlugin(ClassLoader classLoader, Path descriptor)
{
private InstalledPluginDescriptor createDescriptor(ClassLoader classLoader, Path descriptor) {
ClassLoader ctxcl = Thread.currentThread().getContextClassLoader();
Thread.currentThread().setContextClassLoader(classLoader);
try
{
return (InstalledPluginDescriptor) context.createUnmarshaller().unmarshal(
descriptor.toFile());
}
catch (JAXBException ex)
{
throw new PluginLoadException(
"could not load plugin desriptor ".concat(descriptor.toString()), ex);
}
finally
{
try {
return (InstalledPluginDescriptor) context.createUnmarshaller().unmarshal(descriptor.toFile());
} catch (JAXBException ex) {
throw new PluginLoadException("could not load plugin desriptor ".concat(descriptor.toString()), ex);
} finally {
Thread.currentThread().setContextClassLoader(ctxcl);
}
}
/**
* Method description
*
*
* @param classLoader
* @param smp
*
* @return
*
* @throws IOException
*/
private InstalledPlugin createPluginWrapper(ClassLoader classLoader,
ExplodedSmp smp)
throws IOException
{
InstalledPlugin wrapper = null;
private InstalledPlugin createPlugin(ClassLoader classLoader, ExplodedSmp smp) throws IOException {
InstalledPlugin plugin = null;
Path directory = smp.getPath();
Path descriptor = directory.resolve(PluginConstants.FILE_DESCRIPTOR);
Path descriptorPath = directory.resolve(PluginConstants.FILE_DESCRIPTOR);
if (Files.exists(descriptor))
{
if (Files.exists(descriptorPath)) {
ClassLoader cl = createClassLoader(classLoader, smp);
InstalledPluginDescriptor plugin = createPlugin(cl, descriptor);
InstalledPluginDescriptor descriptor = createDescriptor(cl, descriptorPath);
WebResourceLoader resourceLoader = createWebResourceLoader(directory);
wrapper = new InstalledPlugin(plugin, cl, resourceLoader, directory);
}
else
{
plugin = new InstalledPlugin(descriptor, cl, resourceLoader, directory);
} else {
logger.warn("found plugin directory without plugin descriptor");
}
return wrapper;
return plugin;
}
/**