340 lines
12 KiB
Java
340 lines
12 KiB
Java
package org.gcube.portlets.admin.resourcemanagement.server;
|
|
|
|
import java.net.URL;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.Comparator;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Properties;
|
|
import java.util.Set;
|
|
import java.util.stream.Collectors;
|
|
|
|
import javax.servlet.ServletContext;
|
|
|
|
import org.gcube.common.authorization.library.provider.AccessTokenProvider;
|
|
import org.gcube.common.keycloak.KeycloakClient;
|
|
import org.gcube.common.keycloak.KeycloakClientFactory;
|
|
import org.gcube.common.keycloak.model.TokenResponse;
|
|
import org.gcube.common.scope.api.ScopeProvider;
|
|
import org.gcube.informationsystem.model.reference.entities.Resource;
|
|
import org.gcube.informationsystem.resourceregistry.api.contexts.ContextCache;
|
|
import org.gcube.informationsystem.resourceregistry.client.ResourceRegistryClient;
|
|
import org.gcube.informationsystem.resourceregistry.client.ResourceRegistryClientFactory;
|
|
import org.gcube.informationsystem.types.reference.Type;
|
|
import org.gcube.portlets.admin.resourcemanagement.shared.resource.CacheList;
|
|
import org.gcube.portlets.admin.resourcemanagement.shared.resource.UtilityResource;
|
|
import org.gcube.resourcemanagement.support.client.views.ResourceTypeDecorator;
|
|
import org.gcube.resourcemanagement.support.shared.types.datamodel.CompleteResourceProfile;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
/**
|
|
*
|
|
* @author pieve mail:alessandro.pieve@isti.cnr.it
|
|
*
|
|
*/
|
|
public class RegistryClientRequester {
|
|
|
|
private static final String CLIENT_PROPERTIES = "/WEB-INF/client.properties";
|
|
|
|
private static final String ENDPOINT = "endpoint";
|
|
private static final String CLIENT_ID = "clientID";
|
|
private static final String SECRET = "secret";
|
|
private static final String ROOT_SCOPE = "rootScope";
|
|
|
|
private static final boolean IncludeContextInHeader = true;
|
|
|
|
private static Logger logger = LoggerFactory.getLogger(RegistryClientRequester.class);
|
|
|
|
private static ResourceRegistryClient resourceRegistryClient;
|
|
|
|
private static KeycloakClient client = KeycloakClientFactory.newInstance();
|
|
|
|
// private static final String endpoint =
|
|
// "https://accounts.dev.d4science.org/auth/realms/d4science/protocol/openid-connect/token";
|
|
// private static final String clientID =
|
|
// "resource-registry-portlet-expieve";
|
|
// private static final String secret =
|
|
// "179bd3bc-5cc4-11ec-bf63-0242ac130001";
|
|
// private static final String rootScope = "/gcube";
|
|
|
|
public static final Set<String> getAvailableContexts(ServletContext servletContext) throws Exception {
|
|
Properties clientProperties=getClientProperties(servletContext);
|
|
String rootScope=clientProperties.getProperty(ROOT_SCOPE);
|
|
logger.info("GetAvailableContexts: [Scope: {}]", rootScope);
|
|
Set<String> contextList = new HashSet<String>();
|
|
ScopeProvider.instance.set(rootScope);
|
|
AccessTokenProvider.instance.set(getTokenForContext(rootScope,clientProperties));
|
|
|
|
try {
|
|
resourceRegistryClient = ResourceRegistryClientFactory.create();
|
|
//resourceRegistryClient.setIncludeContextsInHeader(IncludeContextInHeader);
|
|
|
|
|
|
ContextCache contextCache = ContextCache.getInstance();
|
|
|
|
contextList = contextCache.getContextFullNameToUUIDAssociation().keySet();
|
|
|
|
} catch (Exception e) {
|
|
logger.error("Error retrieving available contexts: {}",e.getLocalizedMessage(),e);
|
|
throw new Exception("Error retrieving available contexts: "+e.getLocalizedMessage(),e);
|
|
} finally {
|
|
AccessTokenProvider.instance.reset();
|
|
ScopeProvider.instance.reset();
|
|
}
|
|
logger.info("Available contexts: {}",contextList);
|
|
return contextList;
|
|
}
|
|
|
|
private static Properties getClientProperties(ServletContext servletContext) throws Exception {
|
|
Properties properties = new Properties();
|
|
properties.load(servletContext.getResourceAsStream(CLIENT_PROPERTIES));
|
|
return properties;
|
|
}
|
|
|
|
private static String getTokenForContext(String context, Properties clientProperties) {
|
|
logger.info("GetTokenForContext: {}",context);
|
|
String endpoint=clientProperties.getProperty(ENDPOINT);
|
|
String clientID=clientProperties.getProperty(CLIENT_ID);
|
|
String secret=clientProperties.getProperty(SECRET);
|
|
|
|
try {
|
|
TokenResponse response = client.queryUMAToken(new URL(endpoint), clientID, secret, context, null);
|
|
return response.getAccessToken();
|
|
|
|
} catch (Exception e) {
|
|
throw new RuntimeException("error getting access token for context " + context, e);
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* For all the resource in the scope retrieves their (type, subtype) values.
|
|
* The result is a list of couples of that form.
|
|
*
|
|
* @return a list of string tuples (type, subtype)
|
|
* @throws Exception
|
|
*/
|
|
|
|
// list a resource with a sub category
|
|
public static final HashMap<String, ArrayList<String>> getResourcesTree(ServletContext servletContext,String scope) throws Exception {
|
|
logger.info("GetResourcesTree: [Scope: {}]", scope);
|
|
Properties clientProperties=getClientProperties(servletContext);
|
|
HashMap<String, ArrayList<String>> retval = new HashMap<String, ArrayList<String>>();
|
|
ScopeProvider.instance.set(scope);
|
|
AccessTokenProvider.instance.set(getTokenForContext(scope,clientProperties));
|
|
try {
|
|
|
|
|
|
resourceRegistryClient = ResourceRegistryClientFactory.create();
|
|
List<Type> types = resourceRegistryClient.getType(Resource.class, true);
|
|
|
|
logger.info("Resources Types: {}", types.size());
|
|
|
|
for (Type t : types) {
|
|
logger.info("Resource Type: {} in {} ", t.getName(), scope);
|
|
if (t.getName() == null) {
|
|
continue;
|
|
}
|
|
String val = null;
|
|
switch (t.getName()) {
|
|
case "Actor":
|
|
val = "Actor";
|
|
break;
|
|
case "LegalBody":
|
|
val = "LegalBody";
|
|
break;
|
|
case "Person":
|
|
val = "Person";
|
|
break;
|
|
case "ConfigurationTemplate":
|
|
val = "ConfigurationTemplate";
|
|
break;
|
|
case "Configuration":
|
|
val = "GenericResource";
|
|
break;
|
|
case "Dataset":
|
|
val = "Dataset";
|
|
break;
|
|
case "ConcreteDataset":
|
|
val = "ConcreteDataset";
|
|
break;
|
|
case "Schema":
|
|
val = "Schema";
|
|
break;
|
|
case "EService":
|
|
val = "RunningInstance";
|
|
break;
|
|
case "RunningPlugin":
|
|
val = "RunningPlugin";
|
|
break;
|
|
case "HostingNode":
|
|
val = "GHN";
|
|
break;
|
|
case "VirtualService":
|
|
val = "VirtualService";
|
|
break;
|
|
case "Site":
|
|
val = "Site";
|
|
break;
|
|
case "Software":
|
|
val = "Software";
|
|
break;
|
|
case "Plugin":
|
|
val = "Plugin";
|
|
break;
|
|
default:
|
|
break;
|
|
|
|
}
|
|
|
|
if (val != null) {
|
|
ArrayList<String> subtrees = new ArrayList<String>();
|
|
try {
|
|
subtrees = UtilityResource.getSubResourcesTreeQuery(resourceRegistryClient, t.getName());
|
|
} catch (Exception e) {
|
|
logger.error(e.getLocalizedMessage(), e);
|
|
}
|
|
retval.put(val, subtrees);
|
|
}
|
|
|
|
}
|
|
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
} finally {
|
|
AccessTokenProvider.instance.reset();
|
|
ScopeProvider.instance.reset();
|
|
}
|
|
|
|
// Create a list from elements of HashMap
|
|
LinkedList<String> list = new LinkedList<String>(retval.keySet());
|
|
|
|
// Sort the list using lambda expression
|
|
Collections.sort(list, new Comparator<String>() {
|
|
@Override
|
|
public int compare(String o1, String o2) {
|
|
return o1.compareTo(o2);
|
|
}
|
|
});
|
|
|
|
logger.info("Sorted Key: {}", list);
|
|
// put data from sorted list to hashmap
|
|
HashMap<String, ArrayList<String>> sortedretval = new LinkedHashMap<String, ArrayList<String>>();
|
|
for (String k : list) {
|
|
sortedretval.put(k, retval.get(k));
|
|
}
|
|
|
|
return sortedretval;
|
|
}
|
|
|
|
// list string (xml formatted) for table
|
|
public static final List<String> getResourcesByTypeSubType(ServletContext servletContext,String scope, String type, String subType)
|
|
throws Exception {
|
|
logger.info("GetResourcesByTypeSubType: [Scope: {}]", scope);
|
|
Properties clientProperties=getClientProperties(servletContext);
|
|
// CacheList.resourceid.clear();
|
|
ScopeProvider.instance.set(scope);
|
|
AccessTokenProvider.instance.set(getTokenForContext(scope,clientProperties));
|
|
try {
|
|
logger.info("GetResourcesByTypeSubType: [Scope: {}, Type: {}, SubType: {}]",
|
|
new String[] { scope, type, subType });
|
|
|
|
resourceRegistryClient = ResourceRegistryClientFactory.create();
|
|
// resourceRegistryClient.setIncludeContextsInHeader(IncludeContextInHeader);
|
|
List<String> resources = new ArrayList<String>();
|
|
|
|
switch (type) {
|
|
case "Actor":
|
|
logger.info("---------------->Actor");
|
|
resources = UtilityResource.createListActor(resourceRegistryClient, type, subType);
|
|
break;
|
|
case "LegalBody":
|
|
logger.info("---------------->LegalBody");
|
|
resources = UtilityResource.createListLegalBody(resourceRegistryClient, type, subType);
|
|
break;
|
|
case "Person":
|
|
logger.info("---------------->Person");
|
|
resources = UtilityResource.createListPerson(resourceRegistryClient, type, subType);
|
|
break;
|
|
case "ConfigurationTemplate":
|
|
logger.info("---------------->ConfigurationTemplate");
|
|
resources = UtilityResource.createListConfigurationTemplate(resourceRegistryClient, type, subType);
|
|
break;
|
|
case "GenericResource":
|
|
logger.info("---------------->Configuration");
|
|
resources = UtilityResource.createListConfiguration(resourceRegistryClient, type, subType);
|
|
break;
|
|
case "Dataset":
|
|
logger.info("---------------->Dataset");
|
|
resources = UtilityResource.createListDataset(resourceRegistryClient, type, subType);
|
|
break;
|
|
case "ConcreteDataset":
|
|
logger.info("---------------->ConcreteDataset");
|
|
resources = UtilityResource.createListConcreteDataset(resourceRegistryClient, type, subType);
|
|
break;
|
|
case "Schema":
|
|
logger.info("---------------->Schema");
|
|
resources = UtilityResource.createListSchema(resourceRegistryClient, type, subType);
|
|
break;
|
|
case "RunningInstance":
|
|
logger.info("---------------->EService");
|
|
resources = UtilityResource.createListEservice(resourceRegistryClient, type, subType);
|
|
break;
|
|
case "RunningPlugin":
|
|
logger.info("---------------->RunningPlugin");
|
|
resources = UtilityResource.createListRunningPlugin(resourceRegistryClient, type, subType);
|
|
break;
|
|
case "GHN":
|
|
logger.info("---------------->HostingNode");
|
|
resources = UtilityResource.createListHostingNode(resourceRegistryClient, type, subType);
|
|
break;
|
|
case "VirtualService":
|
|
logger.info("---------------->VirtualService");
|
|
resources = UtilityResource.createListVirtualService(resourceRegistryClient, type, subType);
|
|
break;
|
|
case "Site":
|
|
logger.info("---------------->Site");
|
|
resources = UtilityResource.createListSite(resourceRegistryClient, type, subType);
|
|
break;
|
|
case "Software":
|
|
logger.info("---------------->Software");
|
|
resources = UtilityResource.createListSoftware(resourceRegistryClient, type, subType);
|
|
break;
|
|
case "Plugin":
|
|
logger.info("---------------->Plugin");
|
|
resources = UtilityResource.createListPlugin(resourceRegistryClient, type, subType);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return resources;
|
|
} finally {
|
|
AccessTokenProvider.instance.reset();
|
|
ScopeProvider.instance.reset();
|
|
}
|
|
|
|
}
|
|
|
|
public static CompleteResourceProfile getResourceByID(String xml2htmlMapping, String scope, String type,
|
|
String resID) {
|
|
logger.info("GetResourceByID: [Scope: {}]", scope);
|
|
String representation = CacheList.resourceid.get(resID).getBody();
|
|
// get resource by id
|
|
String title = CacheList.resourceid.get(resID).getTitle();
|
|
String xmlRepresentation = "<Resource>" + "<ID>" + resID + "</ID>" + "<Type>" + type + "</Type>" + "<Scope>"
|
|
+ scope + "</Scope>" + representation + "</Resource>";
|
|
String htmlRepresentation = representation;
|
|
ScopeProvider.instance.set(scope);
|
|
return new CompleteResourceProfile(resID, ResourceTypeDecorator.valueOf(type), title, xmlRepresentation,
|
|
htmlRepresentation);
|
|
}
|
|
|
|
}
|