From 0f3975bd79150b34de2df5140f0e72571ca33754 Mon Sep 17 00:00:00 2001 From: "lucio.lelii" Date: Wed, 23 Dec 2020 10:42:07 +0100 Subject: [PATCH] Operation framework added --- .settings/org.eclipse.wst.common.component | 33 ++++--- pom.xml | 6 ++ .../contextmanager/ContextAppManager.java | 26 ------ ...ontextHandler.java => ContextManager.java} | 25 +++-- .../ContextServiceAppManager.java | 41 +++++++++ .../{LogFactory.java => Factories.java} | 6 +- .../contextmanager/ResourceManager.java | 74 +++++---------- .../contextmanager/ScopeDescriptor.java | 3 +- .../contextmanager/ScopeInitializer.java | 28 +++--- .../contextmanager/ScopedResource.java | 4 +- .../collector/LegacyISConnector.java | 91 ++++++++++++++----- .../handlers/ContextContainer.java | 2 - .../handlers/impl/ContextContainerImpl.java | 9 +- .../handlers/impl/ContextTree.java | 22 +++-- .../handlers/impl/DynamicResourceHandler.java | 9 +- .../handlers/impl/StaticResourceHandler.java | 14 +-- .../operators/StorageHubOperation.java | 67 ++++++++++++++ .../services/ContextService.java | 57 ++++++------ ...ester.java => BackendCollectorTester.java} | 4 +- .../ContextServiceIntegrationTest.java | 12 +-- .../contextmanager/ScopeTester.java | 70 +++++++++++++- .../operations/MandatoryVREOperationTest.java | 51 +++++++++++ 22 files changed, 446 insertions(+), 208 deletions(-) delete mode 100644 src/main/java/org/gcube/vremanagement/contextmanager/ContextAppManager.java rename src/main/java/org/gcube/vremanagement/contextmanager/{handlers/ContextHandler.java => ContextManager.java} (63%) create mode 100644 src/main/java/org/gcube/vremanagement/contextmanager/ContextServiceAppManager.java rename src/main/java/org/gcube/vremanagement/contextmanager/{LogFactory.java => Factories.java} (63%) create mode 100644 src/main/java/org/gcube/vremanagement/contextmanager/operators/StorageHubOperation.java rename src/test/java/org/gcube/vremanagement/contextmanager/{BackendConnectorTester.java => BackendCollectorTester.java} (86%) create mode 100644 src/test/java/org/gcube/vremanagement/contextmanager/operations/MandatoryVREOperationTest.java diff --git a/.settings/org.eclipse.wst.common.component b/.settings/org.eclipse.wst.common.component index 6587437..d5ecf18 100644 --- a/.settings/org.eclipse.wst.common.component +++ b/.settings/org.eclipse.wst.common.component @@ -1,44 +1,53 @@ - + + - + + - + + - + + - - - - + + + uses - - + + uses + + + + - + + - + + diff --git a/pom.xml b/pom.xml index 3acacf8..203af9c 100644 --- a/pom.xml +++ b/pom.xml @@ -37,6 +37,12 @@ [1.0.0-SNAPSHOT, 2.0.0-SNAPSHOT) + + org.gcube.common + storagehub-client-library + [1.2.0-SNASPHOT, 2.0.0-SNAPSHOT) + + org.gcube.resources common-gcore-resources diff --git a/src/main/java/org/gcube/vremanagement/contextmanager/ContextAppManager.java b/src/main/java/org/gcube/vremanagement/contextmanager/ContextAppManager.java deleted file mode 100644 index a7a0c78..0000000 --- a/src/main/java/org/gcube/vremanagement/contextmanager/ContextAppManager.java +++ /dev/null @@ -1,26 +0,0 @@ -package org.gcube.vremanagement.contextmanager; - - -import javax.inject.Inject; - -import org.gcube.common.scope.api.ScopeProvider; -import org.gcube.smartgears.ApplicationManager; -import org.slf4j.Logger; - -public class ContextAppManager implements ApplicationManager { - - @Inject Logger logger; - - @Inject ScopeInitializer scopeInitializer; - - @Override - public void onInit() { - String currentContext = ScopeProvider.instance.get(); - scopeInitializer.initScope(currentContext); - } - - @Override - public void onShutdown() { - } - -} diff --git a/src/main/java/org/gcube/vremanagement/contextmanager/handlers/ContextHandler.java b/src/main/java/org/gcube/vremanagement/contextmanager/ContextManager.java similarity index 63% rename from src/main/java/org/gcube/vremanagement/contextmanager/handlers/ContextHandler.java rename to src/main/java/org/gcube/vremanagement/contextmanager/ContextManager.java index c0aded5..85a7027 100644 --- a/src/main/java/org/gcube/vremanagement/contextmanager/handlers/ContextHandler.java +++ b/src/main/java/org/gcube/vremanagement/contextmanager/ContextManager.java @@ -1,4 +1,4 @@ -package org.gcube.vremanagement.contextmanager.handlers; +package org.gcube.vremanagement.contextmanager; import java.util.List; @@ -7,35 +7,33 @@ import javax.enterprise.inject.Instance; import javax.inject.Inject; import javax.inject.Singleton; -import org.gcube.common.authorization.library.provider.SecurityTokenProvider; -import org.gcube.vremanagement.contextmanager.ContextAppManager; import org.gcube.vremanagement.contextmanager.exceptions.ContextAlreadyExistsException; +import org.gcube.vremanagement.contextmanager.handlers.ContextContainer; import org.gcube.vremanagement.contextmanager.model.exceptions.InvalidContextException; import org.gcube.vremanagement.contextmanager.model.operators.context.CustomContextOperator; import org.gcube.vremanagement.contextmanager.model.operators.context.MandatoryContextOperator; import org.gcube.vremanagement.contextmanager.model.types.Context; import org.gcube.vremanagement.contextmanager.model.types.Context.Type; import org.slf4j.Logger; -import org.slf4j.LoggerFactory; @Singleton -public class ContextHandler { +public class ContextManager { - private static Logger log = LoggerFactory.getLogger(ContextHandler.class); + @Inject Logger log; @Inject @Any - Instance mandatoryContextOperators; + private Instance mandatoryContextOperators; @Inject @Any - Instance customContextOperators; + private Instance customContextOperators; @Inject - ContextContainer contextContainer; + private ContextContainer contextContainer; - public void createContext(String parentContextId, String vreName, List resourcesIds, ContextAppManager appContext) throws InvalidContextException { + public void createContext(String parentContextId, String vreName, List resourcesIds) throws InvalidContextException { Context parentContext = contextContainer.getContextById(parentContextId); Context newContext = new Context(parentContext, vreName, vreName, Type.VRE); @@ -49,12 +47,13 @@ public class ContextHandler { log.debug("resource {} added", resourceId); } - mandatoryContextOperators.forEach(co -> co.onCreateContext(SecurityTokenProvider.instance.get(), newContext.getId(), null)); + mandatoryContextOperators.forEach(co -> co.onCreate(newContext)); } - public void disposeContext(String contextId, ContextAppManager appContext) throws InvalidContextException { + public void disposeContext(String contextId) throws InvalidContextException { + Context context = contextContainer.getContextById(contextId); contextContainer.removeContext(contextId); - mandatoryContextOperators.forEach(co -> co.onDisposeContext(SecurityTokenProvider.instance.get(), contextId, null)); + mandatoryContextOperators.forEach(co -> co.onDispose(context)); } public List getAvailableContexts(){ diff --git a/src/main/java/org/gcube/vremanagement/contextmanager/ContextServiceAppManager.java b/src/main/java/org/gcube/vremanagement/contextmanager/ContextServiceAppManager.java new file mode 100644 index 0000000..1cae939 --- /dev/null +++ b/src/main/java/org/gcube/vremanagement/contextmanager/ContextServiceAppManager.java @@ -0,0 +1,41 @@ +package org.gcube.vremanagement.contextmanager; + + +import java.util.HashSet; +import java.util.Set; + +import javax.inject.Inject; + +import org.gcube.common.scope.api.ScopeProvider; +import org.gcube.smartgears.ApplicationManager; +import org.gcube.vremanagement.contextmanager.model.types.Context; +import org.slf4j.Logger; + +public class ContextServiceAppManager implements ApplicationManager { + + @Inject Logger logger; + + @Inject ScopeInitializer scopeInitializer; + + private static Set managedScope =new HashSet<>(); + + @Override + public void onInit() { + String currentContext = ScopeProvider.instance.get(); + scopeInitializer.initScope(currentContext); + managedScope.add(currentContext); + } + + @Override + public void onShutdown() { + } + + public boolean isManaged(Context context){ + if (context.getType()==Context.Type.VRE) + return managedScope.contains(context.getParent().getId()); + else + return managedScope.contains(context.getId()); + } + + +} diff --git a/src/main/java/org/gcube/vremanagement/contextmanager/LogFactory.java b/src/main/java/org/gcube/vremanagement/contextmanager/Factories.java similarity index 63% rename from src/main/java/org/gcube/vremanagement/contextmanager/LogFactory.java rename to src/main/java/org/gcube/vremanagement/contextmanager/Factories.java index 2fc4a46..183fedd 100644 --- a/src/main/java/org/gcube/vremanagement/contextmanager/LogFactory.java +++ b/src/main/java/org/gcube/vremanagement/contextmanager/Factories.java @@ -3,13 +3,17 @@ package org.gcube.vremanagement.contextmanager; import javax.enterprise.inject.Produces; import javax.enterprise.inject.spi.InjectionPoint; +import org.gcube.smartgears.ApplicationManagerProvider; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -class LogFactory { +class Factories { @Produces public Logger createLogger(InjectionPoint injectionPoint) { return LoggerFactory.getLogger(injectionPoint.getMember().getDeclaringClass()); } + @Produces public ContextServiceAppManager createAppManager() { + return (ContextServiceAppManager)ApplicationManagerProvider.get(); + } } diff --git a/src/main/java/org/gcube/vremanagement/contextmanager/ResourceManager.java b/src/main/java/org/gcube/vremanagement/contextmanager/ResourceManager.java index e50e7ee..77d51c6 100644 --- a/src/main/java/org/gcube/vremanagement/contextmanager/ResourceManager.java +++ b/src/main/java/org/gcube/vremanagement/contextmanager/ResourceManager.java @@ -10,9 +10,13 @@ import javax.inject.Singleton; import org.gcube.common.resources.gcore.Resource; import org.gcube.common.resources.gcore.Resource.Type; +import org.gcube.vremanagement.contextmanager.handlers.ContextContainer; import org.gcube.vremanagement.contextmanager.handlers.ResourceHandler; -import org.gcube.vremanagement.contextmanager.model.collectors.BackendConnector; +import org.gcube.vremanagement.contextmanager.model.collectors.CollectorsBackend; +import org.gcube.vremanagement.contextmanager.model.exceptions.InvalidContextException; import org.gcube.vremanagement.contextmanager.model.types.Context; +import org.jboss.weld.exceptions.IllegalArgumentException; +import org.slf4j.Logger; @Singleton @@ -24,78 +28,44 @@ public class ResourceManager { @Inject @Default - BackendConnector defaultCollector; - - public ScopedResource addResourceToContext(Context context, Resource resource) { - ResourceHandler handler = retrieveHandler(resource.type()); - handler.addResource(context, resource); - return getScopedResource(resource); + CollectorsBackend defaultCollector; + + @Inject + ContextContainer contextContainer; + + @Inject Logger log; + + public ScopedResource addResourceToContext(Context context, String id) throws InvalidContextException { + Resource res = retrieveResource(id); + ResourceHandler handler = retrieveHandler(res.type()); + handler.addResource(context, res); + contextContainer.addResource(context.getId(), id); + return getScopedResource(res); } - public ScopedResource removeResourceFromContext(Context context, String id ) { + public ScopedResource removeResourceFromContext(Context context, String id ) throws InvalidContextException { Resource res = retrieveResource(id); ResourceHandler handler = retrieveHandler(res.type()); handler.removeResource(context, res); + contextContainer.removeResource(context.getId(), id); return getScopedResource(res); } private Resource retrieveResource(String id) { return defaultCollector.find(id); - /* - XQuery query = ICFactory.queryFor(Resource.class); - query.addCondition(String.format("$resource/ID/text() eq '%s'",id)); - query.setResult("{$resource/Type}{$resource}"); - DiscoveryClient client = ICFactory.clientWith(new ResourceParser()); - List resources = client.submit(query); - //TODO check return size - return resources.get(0); - public static class ResourceParser implements ResultParser{ - - private enum ResourceType { - GenericResource(GenericResource.class), - RuntimeResource(ServiceEndpoint.class), - RunningInstance(GCoreEndpoint.class), - Service(Software.class), - GHN(HostingNode.class); - - private Class managerClass; - - ResourceType(Class managerClass) { - this.managerClass = managerClass; - } - - public Class getManagerClass(){ - return this.managerClass; - } - } - - @Override - public Resource parse(String res) throws Exception { - String type = res.replaceAll("\\s*([^<]*).*", "$1"); - String resource = res.replaceAll(".*(.*).*", "$1"); - Class classForUnmrshalling= ResourceType.valueOf(type).getManagerClass(); - return Resources.unmarshal(classForUnmrshalling, new StringReader(resource)); - } - - - } - - - */ } private ResourceHandler retrieveHandler(Type type) { Iterator it = resourcesHandlers.iterator(); while (it.hasNext()) { ResourceHandler rh = it.next(); + log.debug("handler {} found",rh.getClass().getSimpleName()); if (rh.getManagedResources().contains(type)) return rh; } - //TODO return handler not found - return null; - + throw new IllegalArgumentException("handler not found"); } private ScopedResource getScopedResource(Resource res) { diff --git a/src/main/java/org/gcube/vremanagement/contextmanager/ScopeDescriptor.java b/src/main/java/org/gcube/vremanagement/contextmanager/ScopeDescriptor.java index a5f3add..554e198 100644 --- a/src/main/java/org/gcube/vremanagement/contextmanager/ScopeDescriptor.java +++ b/src/main/java/org/gcube/vremanagement/contextmanager/ScopeDescriptor.java @@ -31,7 +31,8 @@ public class ScopeDescriptor { @XmlElement(name = "SecurityEnabled") boolean secure = false; - + + @XmlElementWrapper(name="ScopedRescources") @XmlElement(name="ScopedRescource") List scopedResources = null; diff --git a/src/main/java/org/gcube/vremanagement/contextmanager/ScopeInitializer.java b/src/main/java/org/gcube/vremanagement/contextmanager/ScopeInitializer.java index 195bf47..072973f 100644 --- a/src/main/java/org/gcube/vremanagement/contextmanager/ScopeInitializer.java +++ b/src/main/java/org/gcube/vremanagement/contextmanager/ScopeInitializer.java @@ -33,8 +33,10 @@ public class ScopeInitializer { public void initScope(String currentContext) { logger.debug("current context is {}",currentContext); + ScopeBean currentScopeBean = new ScopeBean(currentContext); + if (currentScopeBean.is(ScopeBean.Type.VRE)) return; try { - createEntireContext(new ScopeBean(currentContext)); + createEntireContext(currentScopeBean); } catch (InvalidContextException e) { logger.error("invalid context {}", currentContext,e); return; @@ -44,14 +46,14 @@ public class ScopeInitializer { logger.info("resource initialization started in {} ",currentContext); SimpleQuery query = queryFor(GenericResource.class); - query.addCondition("$resource/Profile/SecondaryType/text eq 'VRE' or $resource/Profile/SecondaryType/text eq 'VO'"); + query.addCondition("$resource/Profile/SecondaryType/text() eq 'VRE' or $resource/Profile/SecondaryType/text() eq 'VO'"); DiscoveryClient client = clientFor(GenericResource.class); List resources = client.submit(query); for (GenericResource resource : resources) { try { String body = resource.profile().bodyAsString(); - ScopeDescriptor scopeDescr = ResourceBinder.get().bind(body); + ScopeDescriptor scopeDescr = ResourceBinder.get().bind(""+body+""); String scope = scopeDescr.context; try { @@ -69,28 +71,32 @@ public class ScopeInitializer { private Context createEntireContext(ScopeBean originalContextBean) throws InvalidContextException{ LinkedList contextList = new LinkedList<>(); - contextList.addFirst(originalContextBean.name()); + contextList.addFirst(originalContextBean.toString()); ScopeBean enclosingScope = originalContextBean.enclosingScope(); while (enclosingScope!=null) { logger.debug("adding scope {} to list",enclosingScope.name()); - String scope = enclosingScope.name(); + String scope = enclosingScope.toString(); contextList.addFirst(scope); enclosingScope = enclosingScope.enclosingScope(); } - Context parentContext = null; + logger.debug("context list is {}",contextList); + + Context actual = null; for (String context : contextList) { logger.debug("adding context {}",context); - int level = context.split("/").length; - String name = context.substring(context.lastIndexOf("/")); + int level = context.split("/").length-2; + String name = context.substring(context.lastIndexOf("/")+1); + logger.debug("adding context name {} and level is {}",name,level); try { - parentContext = new Context(parentContext,context, name, Type.values()[level]); - contextContainer.addContext(parentContext); + Context parentContext = actual; + actual = new Context(parentContext,context, name, Type.values()[level]); + contextContainer.addContext(actual); } catch (ContextAlreadyExistsException e) { logger.warn("context {} already exists", context,e); } } - return parentContext; + return actual; } } diff --git a/src/main/java/org/gcube/vremanagement/contextmanager/ScopedResource.java b/src/main/java/org/gcube/vremanagement/contextmanager/ScopedResource.java index 0f327ad..dd24070 100644 --- a/src/main/java/org/gcube/vremanagement/contextmanager/ScopedResource.java +++ b/src/main/java/org/gcube/vremanagement/contextmanager/ScopedResource.java @@ -20,9 +20,9 @@ public class ScopedResource { @XmlElement(name = "HostedOn") String hostedOn; + + protected ScopedResource() {} - - public ScopedResource(String id, String type, String jointTime) { super(); this.id = id; diff --git a/src/main/java/org/gcube/vremanagement/contextmanager/collector/LegacyISConnector.java b/src/main/java/org/gcube/vremanagement/contextmanager/collector/LegacyISConnector.java index f49854c..df6ecdd 100644 --- a/src/main/java/org/gcube/vremanagement/contextmanager/collector/LegacyISConnector.java +++ b/src/main/java/org/gcube/vremanagement/contextmanager/collector/LegacyISConnector.java @@ -1,39 +1,49 @@ package org.gcube.vremanagement.contextmanager.collector; +import java.io.StringReader; import java.io.StringWriter; import java.util.List; import javax.enterprise.inject.Default; +import javax.inject.Inject; import javax.inject.Singleton; import javax.ws.rs.client.Client; import javax.ws.rs.client.ClientBuilder; import javax.ws.rs.client.Entity; import javax.ws.rs.client.WebTarget; import javax.ws.rs.core.MediaType; +import javax.ws.rs.core.Response; +import javax.ws.rs.core.Response.Status.Family; +import org.gcube.common.resources.gcore.GCoreEndpoint; +import org.gcube.common.resources.gcore.GenericResource; +import org.gcube.common.resources.gcore.HostingNode; import org.gcube.common.resources.gcore.Resource; +import org.gcube.common.resources.gcore.Resource.Type; import org.gcube.common.resources.gcore.Resources; +import org.gcube.common.resources.gcore.ServiceEndpoint; +import org.gcube.common.scope.api.ScopeProvider; import org.gcube.common.scope.api.ServiceMap; import org.gcube.common.scope.impl.ScopedServiceMap; import org.gcube.vremanagement.contextmanager.Utils; -import org.gcube.vremanagement.contextmanager.model.collectors.BackendConnector; +import org.gcube.vremanagement.contextmanager.model.collectors.CollectorsBackend; import org.gcube.vremanagement.contextmanager.model.types.Context; +import org.slf4j.Logger; @Singleton @Default -public class LegacyISConnector implements BackendConnector { +public class LegacyISConnector implements CollectorsBackend { + @Inject Logger log; private Client client = ClientBuilder.newClient(); private static final String RESOURCE_SERVICE = "XMLStoreService"; - @Override public Resource find(String resourceId) { - ServiceMap map = ScopedServiceMap.instance; - String service = map.endpoint(RESOURCE_SERVICE); - WebTarget webTarget = client.target(service).path(resourceId); - return webTarget.request(MediaType.APPLICATION_XML).get(Resource.class); + WebTarget webTarget = getWebTarget().path(resourceId); + String res = webTarget.request(MediaType.APPLICATION_XML).get(String.class); + return parseResource(res); } @Override @@ -49,32 +59,32 @@ public class LegacyISConnector implements BackendConnector { public boolean addResourceToContext(Context context, Resource resource) { String completeContext = Utils.getScopeFromContext(context); resource.scopes().asCollection().add(completeContext); - ServiceMap map = ScopedServiceMap.instance; - String service = map.endpoint(RESOURCE_SERVICE); - WebTarget webTarget = client.target(service).path(resource.type().name()).path(resource.id()); + + WebTarget webTarget = getWebTarget().path(resource.type().toString()).path(resource.id()); StringWriter writer = new StringWriter(); Resources.marshal(resource, writer); - String ret = webTarget.request(MediaType.TEXT_XML).put(Entity.text(writer.toString()), String.class); - return ret!=null; + Response response = webTarget.request(MediaType.TEXT_XML).put(Entity.entity(writer.toString(), MediaType.TEXT_XML)); + return response.getStatusInfo().getFamily()==Family.SUCCESSFUL; } @Override public boolean removeResourceFromContext(Context context, Resource resource) { + String completeContext = Utils.getScopeFromContext(context); resource.scopes().asCollection().remove(completeContext); - ServiceMap map = ScopedServiceMap.instance; - String service = map.endpoint(RESOURCE_SERVICE); - WebTarget webTarget = client.target(service).path(resource.type().name()).path(resource.id()); - String ret; + WebTarget webTarget = getWebTarget().path(resource.type().toString()).path(resource.id()); + + Response response; if (resource.scopes().size()>0) { StringWriter writer = new StringWriter(); Resources.marshal(resource, writer); - ret = webTarget.request(MediaType.TEXT_XML).put(Entity.text(writer.toString()), String.class); - } else { - ret = webTarget.request().delete(String.class); - } - return ret!=null; + response = webTarget.request(MediaType.TEXT_XML).put(Entity.entity(writer.toString(), MediaType.TEXT_XML)); + return response.getStatusInfo().getFamily()==Family.SUCCESSFUL; + } else + response = webTarget.request().delete(); + + return response.getStatusInfo().getFamily()==Family.SUCCESSFUL; } @Override @@ -83,4 +93,43 @@ public class LegacyISConnector implements BackendConnector { return false; } + + private WebTarget getWebTarget() { + ServiceMap map = ScopedServiceMap.instance; + String service = map.endpoint(RESOURCE_SERVICE); + + return client.target(service).queryParam("gcube-scope", ScopeProvider.instance.get()); + } + + private Resource parseResource(String res) { + String typeString = res.substring(res.indexOf("")+"".length(), res.indexOf("")); + Type type = null; + for (Type resType : Type.values()) + if (resType.toString().equals(typeString)) { + type = resType; + break; + } + + + Class resClass = null; + switch (type) { + case ENDPOINT: + resClass = ServiceEndpoint.class; + break; + case GCOREENDPOINT: + resClass = GCoreEndpoint.class; + break; + case NODE: + resClass = HostingNode.class; + break; + case GENERIC: + resClass = GenericResource.class; + break; + default: + break; + } + + return Resources.unmarshal(resClass, new StringReader(res)); + } + } diff --git a/src/main/java/org/gcube/vremanagement/contextmanager/handlers/ContextContainer.java b/src/main/java/org/gcube/vremanagement/contextmanager/handlers/ContextContainer.java index 6993094..cfb39e6 100644 --- a/src/main/java/org/gcube/vremanagement/contextmanager/handlers/ContextContainer.java +++ b/src/main/java/org/gcube/vremanagement/contextmanager/handlers/ContextContainer.java @@ -2,8 +2,6 @@ package org.gcube.vremanagement.contextmanager.handlers; import java.util.List; -import javax.inject.Singleton; - import org.gcube.vremanagement.contextmanager.exceptions.ContextAlreadyExistsException; import org.gcube.vremanagement.contextmanager.model.exceptions.InvalidContextException; import org.gcube.vremanagement.contextmanager.model.types.Context; diff --git a/src/main/java/org/gcube/vremanagement/contextmanager/handlers/impl/ContextContainerImpl.java b/src/main/java/org/gcube/vremanagement/contextmanager/handlers/impl/ContextContainerImpl.java index 8af6694..7896306 100644 --- a/src/main/java/org/gcube/vremanagement/contextmanager/handlers/impl/ContextContainerImpl.java +++ b/src/main/java/org/gcube/vremanagement/contextmanager/handlers/impl/ContextContainerImpl.java @@ -7,6 +7,7 @@ import java.util.List; import java.util.Map; import javax.enterprise.inject.Default; +import javax.inject.Inject; import javax.inject.Singleton; import org.gcube.vremanagement.contextmanager.exceptions.ContextAlreadyExistsException; @@ -21,20 +22,22 @@ public class ContextContainerImpl implements ContextContainer { private Map> resourceMap = new HashMap<>(); - private static ContextTree contextTree = new ContextTree() { + @Inject ContextTree contextTree; + + /*private static ContextTree contextTree = new ContextTree() { @Override public void init() { } - }; + };*/ public List getAvailableContexts() { return contextTree.getContexts(); } public void addContext(Context toAdd) throws InvalidContextException, ContextAlreadyExistsException{ - contextTree.createItem(toAdd==null?null:toAdd.getId(), toAdd); + contextTree.createItem(toAdd.getParent()==null?null:toAdd.getParent().getId(), toAdd); } public void removeContext(String contextId) throws InvalidContextException { diff --git a/src/main/java/org/gcube/vremanagement/contextmanager/handlers/impl/ContextTree.java b/src/main/java/org/gcube/vremanagement/contextmanager/handlers/impl/ContextTree.java index 00334fb..d68283c 100644 --- a/src/main/java/org/gcube/vremanagement/contextmanager/handlers/impl/ContextTree.java +++ b/src/main/java/org/gcube/vremanagement/contextmanager/handlers/impl/ContextTree.java @@ -4,28 +4,27 @@ import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; -import java.util.Set; import javax.inject.Inject; +import javax.inject.Singleton; +import org.gcube.vremanagement.contextmanager.exceptions.ContextAlreadyExistsException; import org.gcube.vremanagement.contextmanager.model.exceptions.InvalidContextException; import org.gcube.vremanagement.contextmanager.model.types.Context; import org.gcube.vremanagement.contextmanager.model.types.Context.Type; import org.slf4j.Logger; -public abstract class ContextTree { +@Singleton +public class ContextTree { @Inject Logger log; - public ContextTree() { - init(); - } private static TreeItem root; private Map values = new HashMap<>(); - public abstract void init(); + public void init() {}; public synchronized TreeItem removeItem(String itemId) { TreeItem item = values.get(itemId); @@ -37,7 +36,8 @@ public abstract class ContextTree { throw new IllegalArgumentException("item is not a leaf"); } - public synchronized TreeItem createItem(String parentId, Context context) throws InvalidContextException { + public synchronized TreeItem createItem(String parentId, Context context) throws InvalidContextException, ContextAlreadyExistsException { + if (values.containsKey(context.getId())) throw new ContextAlreadyExistsException("context with id "+context.getId()+" already exist"); log.debug("creating item {} with parentId {}", context, parentId); TreeItem item; if (parentId==null) { @@ -63,16 +63,18 @@ public abstract class ContextTree { } public List getContexts(){ - log.debug("searching for contexts"); + return new ArrayList<>(values.keySet()); + /*log.debug("searching for contexts"); List toReturn = new ArrayList<>(); String rootString = "/"+root.getContext().getId(); toReturn.add(rootString); if (!root.isLeaf()) toReturn.addAll(deepSearch(root.getChildren(), rootString)); log.debug("found {} contexts", toReturn.size()); - return toReturn; + return toReturn;*/ } + /* private List deepSearch(Set children, String parentString) { List toReturn = new ArrayList<>(); for (TreeItem item : children) { @@ -82,6 +84,6 @@ public abstract class ContextTree { toReturn.addAll(deepSearch(item.getChildren(), itemString)); } return toReturn; - } + }*/ } diff --git a/src/main/java/org/gcube/vremanagement/contextmanager/handlers/impl/DynamicResourceHandler.java b/src/main/java/org/gcube/vremanagement/contextmanager/handlers/impl/DynamicResourceHandler.java index af0a430..9632e8a 100644 --- a/src/main/java/org/gcube/vremanagement/contextmanager/handlers/impl/DynamicResourceHandler.java +++ b/src/main/java/org/gcube/vremanagement/contextmanager/handlers/impl/DynamicResourceHandler.java @@ -3,21 +3,16 @@ package org.gcube.vremanagement.contextmanager.handlers.impl; import java.util.Arrays; import java.util.List; -import javax.enterprise.inject.Default; -import javax.inject.Inject; +import javax.inject.Singleton; import org.gcube.common.resources.gcore.Resource; import org.gcube.common.resources.gcore.Resource.Type; import org.gcube.vremanagement.contextmanager.handlers.ResourceHandler; -import org.gcube.vremanagement.contextmanager.model.collectors.BackendConnector; import org.gcube.vremanagement.contextmanager.model.types.Context; - +@Singleton public class DynamicResourceHandler implements ResourceHandler { - @Inject - @Default - BackendConnector defaultCollector; @Override public List getManagedResources() { diff --git a/src/main/java/org/gcube/vremanagement/contextmanager/handlers/impl/StaticResourceHandler.java b/src/main/java/org/gcube/vremanagement/contextmanager/handlers/impl/StaticResourceHandler.java index 7ee5aac..643fdd1 100644 --- a/src/main/java/org/gcube/vremanagement/contextmanager/handlers/impl/StaticResourceHandler.java +++ b/src/main/java/org/gcube/vremanagement/contextmanager/handlers/impl/StaticResourceHandler.java @@ -6,14 +6,16 @@ import java.util.List; import javax.enterprise.inject.Any; import javax.enterprise.inject.Instance; import javax.inject.Inject; +import javax.inject.Singleton; import org.gcube.common.resources.gcore.Resource; import org.gcube.common.resources.gcore.Resource.Type; import org.gcube.vremanagement.contextmanager.handlers.ResourceHandler; -import org.gcube.vremanagement.contextmanager.model.collectors.BackendConnector; +import org.gcube.vremanagement.contextmanager.model.collectors.CollectorsBackend; import org.gcube.vremanagement.contextmanager.model.types.Context; import org.slf4j.Logger; +@Singleton public class StaticResourceHandler implements ResourceHandler { @Inject @@ -21,7 +23,7 @@ public class StaticResourceHandler implements ResourceHandler { @Inject @Any - Instance connectors; + Instance connectors; @Override public List getManagedResources() { @@ -30,21 +32,21 @@ public class StaticResourceHandler implements ResourceHandler { @Override public void addResource(Context context, Resource resource) { - for (BackendConnector connector : connectors) + for (CollectorsBackend connector : connectors) try { connector.addResourceToContext(context, resource); }catch (Exception e) { - log.warn("error adding context {} in resource with id {} ",resource.id(), context.getName()); + log.warn("error adding context {} in resource with id {} ",context.getName() ,resource.id() ,e); } } @Override public void removeResource(Context context, Resource resource) { - for (BackendConnector connector : connectors) + for (CollectorsBackend connector : connectors) try { connector.removeResourceFromContext(context, resource); }catch (Exception e) { - log.warn("error removing context {} in resource with id {} ",resource.id(), context.getName()); + log.warn("error removing context {} in resource with id {} ",context.getName() ,resource.id(), e); } } diff --git a/src/main/java/org/gcube/vremanagement/contextmanager/operators/StorageHubOperation.java b/src/main/java/org/gcube/vremanagement/contextmanager/operators/StorageHubOperation.java new file mode 100644 index 0000000..40db443 --- /dev/null +++ b/src/main/java/org/gcube/vremanagement/contextmanager/operators/StorageHubOperation.java @@ -0,0 +1,67 @@ +package org.gcube.vremanagement.contextmanager.operators; + +import java.util.UUID; + +import org.gcube.common.authorization.library.provider.AuthorizationProvider; +import org.gcube.common.storagehub.client.dsl.StorageHubClient; +import org.gcube.common.storagehub.model.acls.AccessType; +import org.gcube.common.storagehub.model.exceptions.StorageHubException; +import org.gcube.vremanagement.contextmanager.model.operators.context.MandatoryContextOperator; +import org.gcube.vremanagement.contextmanager.model.report.OperationResult; +import org.gcube.vremanagement.contextmanager.model.types.Context; +import org.gcube.vremanagement.contextmanager.model.types.Context.Type; + +public class StorageHubOperation implements MandatoryContextOperator{ + + private String id = UUID.randomUUID().toString(); + + StorageHubClient client = new StorageHubClient(); + + @Override + public OperationResult onCreate(Context context) { + + try { + client.getVreFolderManager().createVRE(AccessType.WRITE_OWNER, AuthorizationProvider.instance.get().getClient().getId()); + } catch (StorageHubException e) { + return OperationResult.failure(e.getErrorMessage()); + } + /*try { + for (String user: users) + client.getVreFolderManager().addUser(userId); + }catch ( e) { + // TODO: handle exception + }*/ + return OperationResult.success(); + } + + @Override + public OperationResult onDispose(Context context) { + try { + client.getVreFolderManager().removeVRE(); + } catch (StorageHubException e) { + + } + return null; + + } + + @Override + public String getName() { + return "StorageHub"; + } + + + public String getDescription() { + return "creates/removes all the needed stuff in Storagehub"; + } + + @Override + public String getOperationId() { + return id; + } + + @Override + public Type getApplicationContextType() { + return Context.Type.VRE; + } +} diff --git a/src/main/java/org/gcube/vremanagement/contextmanager/services/ContextService.java b/src/main/java/org/gcube/vremanagement/contextmanager/services/ContextService.java index 09e9655..da42236 100644 --- a/src/main/java/org/gcube/vremanagement/contextmanager/services/ContextService.java +++ b/src/main/java/org/gcube/vremanagement/contextmanager/services/ContextService.java @@ -7,6 +7,7 @@ import javax.inject.Inject; import javax.ws.rs.Consumes; import javax.ws.rs.DELETE; import javax.ws.rs.GET; +import javax.ws.rs.POST; import javax.ws.rs.PUT; import javax.ws.rs.Path; import javax.ws.rs.PathParam; @@ -14,33 +15,31 @@ import javax.ws.rs.Produces; import javax.ws.rs.WebApplicationException; import javax.ws.rs.core.MediaType; -import org.gcube.common.resources.gcore.Resource; import org.gcube.common.scope.api.ScopeProvider; -import org.gcube.smartgears.ApplicationManagerProvider; -import org.gcube.smartgears.ContextProvider; import org.gcube.smartgears.annotations.ManagedBy; -import org.gcube.smartgears.context.application.ApplicationContext; -import org.gcube.vremanagement.contextmanager.ContextAppManager; +import org.gcube.vremanagement.contextmanager.ContextManager; +import org.gcube.vremanagement.contextmanager.ContextServiceAppManager; import org.gcube.vremanagement.contextmanager.ResourceManager; import org.gcube.vremanagement.contextmanager.Utils; import org.gcube.vremanagement.contextmanager.handlers.ContextContainer; -import org.gcube.vremanagement.contextmanager.handlers.ContextHandler; +import org.gcube.vremanagement.contextmanager.model.exceptions.InvalidContextException; import org.gcube.vremanagement.contextmanager.model.types.Context; import org.gcube.vremanagement.contextmanager.model.types.StringList; import org.glassfish.jersey.media.multipart.FormDataParam; import org.slf4j.Logger; -import org.slf4j.LoggerFactory; @Path("contexts") -@ManagedBy(ContextAppManager.class) +@ManagedBy(ContextServiceAppManager.class) public class ContextService { - private static Logger log = LoggerFactory.getLogger(ContextService.class); + @Inject Logger log; - ApplicationContext appContext = ContextProvider.get(); - + @RequestScoped @Inject - ContextHandler contextHandler; + ContextServiceAppManager appManager ; + + @Inject + ContextManager contextHandler; @Inject ResourceManager resourceHandler; @@ -68,7 +67,7 @@ public class ContextService { } } - @PUT + @POST @Consumes(MediaType.MULTIPART_FORM_DATA) @Path("/{contextId}") public void createVREContext(@FormDataParam("resources") StringList resourceIds, @FormDataParam("vreName") String vreName ){ @@ -76,7 +75,7 @@ public class ContextService { try { //validate Call - contextHandler.createContext(contextId, vreName, resourceIds.getValues(), (ContextAppManager)ApplicationManagerProvider.get()); + contextHandler.createContext(contextId, vreName, resourceIds.getValues()); }catch (Exception e) { log.error("error creating context {}",contextId,e); throw new WebApplicationException(e); @@ -92,7 +91,7 @@ public class ContextService { //Context context = contextContainer.getContextById(contextId); //validateCall(fullContext); - contextHandler.disposeContext(contextId, (ContextAppManager)ApplicationManagerProvider.get()); + contextHandler.disposeContext(contextId); }catch (Exception e) { log.error("error disposing context {}",contextId,e); throw new WebApplicationException(e); @@ -100,7 +99,7 @@ public class ContextService { } @DELETE - @Path("/{contextId}/resources/{resourceId}") + @Path("/{contextId:(.*(?=/resources))}/resources/{resourceId}") public void removeResourceFromContext(@PathParam("resourceId") String resourceId) { log.info("remove resource {} from context {}", resourceId, contextId); try { @@ -113,23 +112,29 @@ public class ContextService { } - //@Path("/{context:(.*(?=/resources))}/resources") + @PUT - @Path("/{contextId}/resources") - public String addResourceToContext(Resource resource) { - /*log.info("adding resource {} to context {}", resource.id(), context); + @Path("/{contextId:(.*(?=/resources))}/resources") + public String addResourceToContext(String resourceId) { + log.info("adding resource {} to context {}", resourceId, contextId); try { - validateCall(context); - resourceHandler.addResourceToContext(context, resource); + Context context = contextContainer.getContextById(contextId); + validateCall(Utils.getScopeFromContext(context)); + if (appManager.isManaged(context)) + resourceHandler.addResourceToContext(context, resourceId); + else { + log.debug("the context {} is not managed", contextId); + //TODO: else manage queue to add resource in another ContextManager + } }catch (Exception e) { // TODO: handle exception - } */ + } return null; } @GET @Produces(MediaType.APPLICATION_JSON) - @Path("/{contextId}/resources") + @Path("/{contextId:(.*(?=/resources))}/resources") public StringList getResources() { log.info("getResource in context {} called",contextId); @@ -144,10 +149,10 @@ public class ContextService { } } - private void validateCall(String fullContext) throws Exception { + private void validateCall(String fullContext) throws InvalidContextException { String currentContext = ScopeProvider.instance.get(); if (!fullContext.startsWith(currentContext)) - throw new Exception("invalid call"); + throw new InvalidContextException("invalid context"); } diff --git a/src/test/java/org/gcube/vremanagement/contextmanager/BackendConnectorTester.java b/src/test/java/org/gcube/vremanagement/contextmanager/BackendCollectorTester.java similarity index 86% rename from src/test/java/org/gcube/vremanagement/contextmanager/BackendConnectorTester.java rename to src/test/java/org/gcube/vremanagement/contextmanager/BackendCollectorTester.java index 2f2f2f7..360e53c 100644 --- a/src/test/java/org/gcube/vremanagement/contextmanager/BackendConnectorTester.java +++ b/src/test/java/org/gcube/vremanagement/contextmanager/BackendCollectorTester.java @@ -5,11 +5,11 @@ import java.util.List; import javax.enterprise.inject.Default; import org.gcube.common.resources.gcore.Resource; -import org.gcube.vremanagement.contextmanager.model.collectors.BackendConnector; +import org.gcube.vremanagement.contextmanager.model.collectors.CollectorsBackend; import org.gcube.vremanagement.contextmanager.model.types.Context; @Default -public class BackendConnectorTester implements BackendConnector { +public class BackendCollectorTester implements CollectorsBackend { @Override public Resource find(String resourceId) { diff --git a/src/test/java/org/gcube/vremanagement/contextmanager/ContextServiceIntegrationTest.java b/src/test/java/org/gcube/vremanagement/contextmanager/ContextServiceIntegrationTest.java index 112dac0..7202b5d 100644 --- a/src/test/java/org/gcube/vremanagement/contextmanager/ContextServiceIntegrationTest.java +++ b/src/test/java/org/gcube/vremanagement/contextmanager/ContextServiceIntegrationTest.java @@ -54,17 +54,7 @@ public class ContextServiceIntegrationTest extends JerseyTest { }); } - @Override - protected void configureClient(ClientConfig config) { - config.register(MultiPartFeature.class) - .register(LogFactory.class).register(new AbstractBinder() { - @Override - protected void configure() { - bind(log).to(Logger.class); - } - }); - - } + @Test public void getContexts_whenCorrectRequest_thenResponseIsOk() { diff --git a/src/test/java/org/gcube/vremanagement/contextmanager/ScopeTester.java b/src/test/java/org/gcube/vremanagement/contextmanager/ScopeTester.java index 5565a64..ae9800e 100644 --- a/src/test/java/org/gcube/vremanagement/contextmanager/ScopeTester.java +++ b/src/test/java/org/gcube/vremanagement/contextmanager/ScopeTester.java @@ -1,23 +1,89 @@ package org.gcube.vremanagement.contextmanager; +import static org.junit.Assert.assertTrue; + +import java.util.Collections; + import javax.inject.Inject; +import org.gcube.common.resources.gcore.Resource; +import org.gcube.common.scope.api.ScopeProvider; +import org.gcube.vremanagement.contextmanager.collector.LegacyISConnector; +import org.gcube.vremanagement.contextmanager.handlers.ContextContainer; import org.gcube.vremanagement.contextmanager.handlers.impl.ContextContainerImpl; +import org.gcube.vremanagement.contextmanager.handlers.impl.DynamicResourceHandler; +import org.gcube.vremanagement.contextmanager.handlers.impl.StaticResourceHandler; +import org.gcube.vremanagement.contextmanager.model.collectors.CollectorsBackend; +import org.gcube.vremanagement.contextmanager.model.exceptions.InvalidContextException; +import org.gcube.vremanagement.contextmanager.model.types.Context; +import org.gcube.vremanagement.contextmanager.operations.MandatoryVREOperationTest; import org.jglue.cdiunit.AdditionalClasses; import org.jglue.cdiunit.CdiRunner; +import org.junit.Before; import org.junit.Test; import org.junit.runner.RunWith; +import org.slf4j.Logger; @RunWith(CdiRunner.class) -@AdditionalClasses({ContextContainerImpl.class, LogFactory.class }) +@AdditionalClasses({ContextContainerImpl.class, Factories.class, + LegacyISConnector.class, DynamicResourceHandler.class, StaticResourceHandler.class, MandatoryVREOperationTest.class }) public class ScopeTester { @Inject ScopeInitializer scopeInitializer; + @Inject ContextContainer container; + + @Inject ContextManager contextManager; + + @Inject CollectorsBackend is; + + @Inject Logger log; + + @Inject ResourceManager resourceManager; + + private static String resourceId = "eabfe9bb-001d-48bc-92dc-586eefdc2006"; + + private static String context = "/gcube/devNext"; + + private static String vreContext = "/gcube/devNext/NextNext"; + + @Before + public void init() { + ScopeProvider.instance.set(context); + scopeInitializer.initScope(context); + + } @Test public void initTest() { - scopeInitializer.initScope("/gcube/devNext"); + + container.getAvailableContexts().forEach(c -> { + try { + container.getResources(c).forEach(r-> log.debug(" {} res {} ",c,r)); + } catch (InvalidContextException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + }); + + } + + @Test + public void addAndRemoveResourceScopeTest() throws InvalidContextException { + Context context = container.getContextById(vreContext); + resourceManager.addResourceToContext(context, resourceId); + assertTrue(container.getResources(vreContext).contains(resourceId)); + Resource res = is.find(resourceId); + assertTrue(res.scopes().asCollection().contains(vreContext)); + log.debug("scopes are {}",res.scopes().asCollection()); + resourceManager.removeResourceFromContext(context, resourceId); + assertTrue(!container.getResources(vreContext).contains(resourceId)); + assertTrue(!is.find(resourceId).scopes().contains(vreContext)); + } + + @Test + public void createContextTest() throws InvalidContextException { + contextManager.createContext(context, "newVRE", Collections.emptyList()); } } diff --git a/src/test/java/org/gcube/vremanagement/contextmanager/operations/MandatoryVREOperationTest.java b/src/test/java/org/gcube/vremanagement/contextmanager/operations/MandatoryVREOperationTest.java new file mode 100644 index 0000000..a08008a --- /dev/null +++ b/src/test/java/org/gcube/vremanagement/contextmanager/operations/MandatoryVREOperationTest.java @@ -0,0 +1,51 @@ +package org.gcube.vremanagement.contextmanager.operations; + +import java.util.UUID; + +import javax.inject.Inject; + +import org.gcube.vremanagement.contextmanager.model.operators.context.MandatoryContextOperator; +import org.gcube.vremanagement.contextmanager.model.report.OperationResult; +import org.gcube.vremanagement.contextmanager.model.types.Context; +import org.gcube.vremanagement.contextmanager.model.types.Context.Type; +import org.slf4j.Logger; + +public class MandatoryVREOperationTest implements MandatoryContextOperator{ + + static String id = UUID.randomUUID().toString(); + + @Inject Logger log; + + @Override + public Type getApplicationContextType() { + return Type.VRE; + } + + @Override + public String getOperationId() { + return id; + } + + @Override + public String getName() { + return "testOp"; + } + + @Override + public String getDescription() { + return "testOp"; + } + + @Override + public OperationResult onCreate(Context context) { + log.debug("executing testOP"); + return OperationResult.success(); + } + + @Override + public OperationResult onDispose(Context context) { + // TODO Auto-generated method stub + return null; + } + +}