331 lines
13 KiB
Java
331 lines
13 KiB
Java
package org.gcube.informationsystem.publisher.utils;
|
|
|
|
import static org.gcube.resources.discovery.icclient.ICFactory.client;
|
|
import static org.gcube.resources.discovery.icclient.ICFactory.clientFor;
|
|
import static org.gcube.resources.discovery.icclient.ICFactory.queryFor;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Date;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
|
|
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.ResourceMediator;
|
|
import org.gcube.common.resources.gcore.ScopeGroup;
|
|
import org.gcube.common.resources.gcore.ServiceEndpoint;
|
|
import org.gcube.common.scope.api.ScopeProvider;
|
|
import org.gcube.common.scope.impl.ScopeBean;
|
|
import org.gcube.common.scope.impl.ScopeBean.Type;
|
|
import org.gcube.informationsystem.publisher.RegistryPublisher;
|
|
import org.gcube.resources.discovery.client.api.DiscoveryClient;
|
|
import org.gcube.resources.discovery.client.queries.api.SimpleQuery;
|
|
import org.gcube.resources.discovery.client.queries.impl.XQuery;
|
|
import org.slf4j.Logger;
|
|
import org.slf4j.LoggerFactory;
|
|
|
|
|
|
public class ValidationUtils {
|
|
|
|
private static final Logger log = LoggerFactory.getLogger(ValidationUtils.class);
|
|
|
|
public static void valid(String name, Object object){
|
|
if (object==null)
|
|
throw new IllegalArgumentException(name+" is null");
|
|
}
|
|
|
|
public static < R extends Resource > boolean isPresent(R resource, String currentScope){
|
|
ScopeGroup<String> scopes=resource.scopes();
|
|
boolean founded= false;
|
|
for(Iterator<String> it=scopes.iterator(); it.hasNext();){
|
|
String scope=it.next();
|
|
if(scope.equals(currentScope))
|
|
founded=true;
|
|
}
|
|
if(founded)
|
|
throw new IllegalArgumentException(" scope "+currentScope+" is already present in resource");
|
|
return false;
|
|
}
|
|
|
|
|
|
/**
|
|
* If scope is a VRE scope and the VO and INFRA scopes are not present in the resource, this method add these scopes to the resource
|
|
* @param resource the resource
|
|
* @param scope a scope
|
|
*/
|
|
public static <T extends Resource> void addEnclosingScopesOnResource(T resource, String scope){
|
|
if(new ScopeBean(scope).is(Type.VRE)){
|
|
String voScope=new ScopeBean(scope).enclosingScope().toString();
|
|
String infraScope=new ScopeBean(voScope).enclosingScope().toString();
|
|
// The scope collection is a set, I can add scope without checking
|
|
log.debug("adding "+voScope+" to the resource "+resource.id());
|
|
ResourceMediator.setScope(resource, voScope);
|
|
log.debug("adding "+infraScope+" to the resource "+resource.id());
|
|
ResourceMediator.setScope(resource, infraScope);
|
|
}else if(new ScopeBean(scope).is(Type.VO)){
|
|
String infraScope=new ScopeBean(scope).enclosingScope().toString();
|
|
log.debug("adding "+infraScope+" to the resource "+resource.id());
|
|
// The scope collection is a set, I can add scope without checking
|
|
ResourceMediator.setScope(resource, infraScope);
|
|
}
|
|
}
|
|
|
|
public static <T extends Resource> boolean isCompatibleScopeForRemove(T resource, String scope){
|
|
log.info("scope: {} check if update is needed inr resource: {}", scope,resource.id());
|
|
if(resource.scopes().size() == 0)
|
|
return true;
|
|
if(new ScopeBean(scope).is(Type.VRE)){
|
|
log.debug(" "+scope+" is a VRE scope");
|
|
if(anotherBrotherVREOrVOOnResource(resource, scope)){
|
|
log.debug("found another VRE or VO scope on the resource: ");
|
|
return false;
|
|
}else return true;
|
|
}else if(new ScopeBean(scope).is(Type.VO)){
|
|
log.debug(" "+scope+" is a VO scope");
|
|
if(anotherSonVREOnResource(resource, scope)){
|
|
return false; //throw new IllegalArgumentException("the resource "+resource.id()+" have another scope defined in the same VO. The VO is "+scope);
|
|
}else return true;
|
|
}else{ // is a INFRA scope
|
|
if(anotherInfraScopeOnResource(resource, scope)){
|
|
return false; //throw new IllegalArgumentException("the resource "+resource.id()+" have another scope defined in the same INFRA. The INFRA is "+scope);
|
|
}else return true;
|
|
}
|
|
}
|
|
|
|
public static <T extends Resource> boolean anotherBrotherVREOrVOOnResource(T resource, String scope){
|
|
if(!new ScopeBean(scope).is(Type.VRE))
|
|
throw new IllegalArgumentException("anotherBrotherVREOrVOOnResource method: the input scope must be a VRE scope");
|
|
String enclosedScope=new ScopeBean(scope).enclosingScope().toString();
|
|
log.debug("VO scope "+enclosedScope);
|
|
for(String s : resource.scopes()){
|
|
log.debug(" check scope "+s);
|
|
if(isChildScope(enclosedScope, s)){
|
|
log.debug("the scope "+s+" is another VRE scope defined in the resource. Not Remove needed ");
|
|
return true;
|
|
}else if((enclosedScope != null) && (enclosedScope.toString().equals(s))){
|
|
log.debug("the scope "+s+" is the father VO scope defined in the resource. Not Remove needed ");
|
|
return true;
|
|
}
|
|
}
|
|
log.debug("other brother VRE scope or VO scope not found on the resource ");
|
|
return false;
|
|
}
|
|
|
|
public static <T extends Resource> boolean anotherSonVREOnResource(T resource, String scope){
|
|
if(!new ScopeBean(scope).is(Type.VO))
|
|
throw new IllegalArgumentException("anotherSonVREOnResource method: the input scope must be a VO scope");
|
|
for(String s : resource.scopes()){
|
|
if(isChildScope(scope, s)){
|
|
log.debug("the scope "+s+" is another VO scope defined in the resource ");
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static boolean isChildScope(String fatherScope, String sonScope) {
|
|
ScopeBean currentEnclosedScope=new ScopeBean(sonScope).enclosingScope();
|
|
if((currentEnclosedScope != null) && (currentEnclosedScope.toString().equals(fatherScope))){
|
|
log.debug("check scope"+fatherScope+": found another son VRE scope "+sonScope);
|
|
return true;
|
|
}else return false;
|
|
}
|
|
|
|
public static <T extends Resource> boolean anotherInfraScopeOnResource(T resource, String scope){
|
|
if(!new ScopeBean(scope).is(Type.INFRASTRUCTURE))
|
|
throw new IllegalArgumentException("anotherInfraScopeOnResource method: the input scope must be a INFRASTRUCTURE scope");
|
|
String infraScopeFound=null;
|
|
for(String s : resource.scopes()){
|
|
while(new ScopeBean(s).enclosingScope() != null){
|
|
s=new ScopeBean(s).enclosingScope().toString();
|
|
|
|
}
|
|
infraScopeFound=s;
|
|
if(infraScopeFound.equals(scope)){
|
|
log.debug("check scope"+scope+": found another scope on infra "+s);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// /**
|
|
// * Given a scope, returns the related VO. If it is a root-VO scope, returns null
|
|
// * @param currentScope
|
|
// * @return
|
|
// */
|
|
// public static String getCurrentVO(String currentScope) {
|
|
// ScopeBean scopeBean = new ScopeBean(currentScope);
|
|
// String currentVO=null;
|
|
// if(scopeBean.is(Type.VRE))
|
|
// currentVO=scopeBean.enclosingScope().toString();
|
|
// else if (scopeBean.is(Type.VO))
|
|
// currentVO= currentScope;
|
|
// else return null;
|
|
// return currentVO;
|
|
// }
|
|
//
|
|
// /**
|
|
// * Returns all the VOs involved. If just a VRE scope is present in the resource, the enclosed VO will be returned.
|
|
// * if present, the root-VO is returned yet
|
|
// * @param resource the gCube resource
|
|
// * @return the VO scopes
|
|
// */
|
|
// public static <T extends Resource> HashSet<String> getInternalVOScopes(T resource) {
|
|
// HashSet<String> vosScopes = new HashSet<String>();
|
|
// log.debug("checking and collect the internal VO scopes");
|
|
// for(String scope: resource.scopes()){
|
|
// log.debug("processing scope: "+scope);
|
|
// ScopeBean scopeBean = new ScopeBean(scope);
|
|
// if(scopeBean.is(Type.VRE))
|
|
// vosScopes.add(scopeBean.enclosingScope().toString());
|
|
//// else if(scopeBean.is(Type.VO))
|
|
// vosScopes.add(scope);
|
|
// }
|
|
// return vosScopes;
|
|
// }
|
|
//
|
|
// public static GenericResource getGenericResourceByID(String id, String latestVO) {
|
|
// List<GenericResource> resources;
|
|
// String currentScope= ScopeProvider.instance.get();
|
|
// try{
|
|
// ScopeProvider.instance.set(latestVO);
|
|
// SimpleQuery query = queryFor(GenericResource.class);
|
|
// query.addCondition("$resource/ID/text() eq '"+id+"'");
|
|
// DiscoveryClient<GenericResource> client = clientFor(GenericResource.class);
|
|
// resources = client.submit(query);
|
|
// }finally{
|
|
// ScopeProvider.instance.set(currentScope);
|
|
// }
|
|
// if (( resources !=null) && (!resources.isEmpty()))
|
|
// return resources.get(0);
|
|
// else{
|
|
// log.info(" No resource found with id "+id+" in scope "+latestVO);
|
|
// return null;
|
|
// }
|
|
// }
|
|
//
|
|
// public static ServiceEndpoint getServiceEndpointByID(String id, String latestVO) {
|
|
// List<ServiceEndpoint> resources;
|
|
// String currentScope= ScopeProvider.instance.get();
|
|
// try{
|
|
// ScopeProvider.instance.set(latestVO);
|
|
// SimpleQuery query = queryFor(ServiceEndpoint.class);
|
|
// query.addCondition("$resource/ID/text() eq '"+id+"'");
|
|
// DiscoveryClient<ServiceEndpoint> client = clientFor(ServiceEndpoint.class);
|
|
// resources = client.submit(query);
|
|
// }finally{
|
|
// ScopeProvider.instance.set(currentScope);
|
|
// }
|
|
// if (( resources !=null) && (!resources.isEmpty()))
|
|
// return resources.get(0);
|
|
// else{
|
|
// log.info(" No resource found with id "+id+" in scope "+latestVO);
|
|
// return null;
|
|
// }
|
|
// }
|
|
//
|
|
// public static <T extends Resource> List<String> getTimestamps(T resource) {
|
|
// XQuery query = getSpecificXQuery(resource);
|
|
// query.addCondition("$resource/ID/text() eq '"+resource.id()+"'");
|
|
// query.setResult("$resource/../../../../Document/LastUpdateMs/text()");
|
|
// DiscoveryClient<String> client = client();
|
|
// List<String> timestamps= client.submit(query);
|
|
// return timestamps;
|
|
// }
|
|
//
|
|
// public static <T extends Resource> XQuery getSpecificXQuery(T resource) {
|
|
// XQuery query = null;
|
|
// if(resource.type().toString().equalsIgnoreCase("RuntimeResource")){
|
|
// query = queryFor(ServiceEndpoint.class);
|
|
// }else if(resource.type().toString().equalsIgnoreCase("GenericResource")){
|
|
// query = queryFor(GenericResource.class);
|
|
// }else if(resource.type().toString().equalsIgnoreCase("RunningInstance")){
|
|
// query = queryFor(GCoreEndpoint.class);
|
|
// }else if(resource.type().toString().equalsIgnoreCase("GHN")){
|
|
// query = queryFor(HostingNode.class);
|
|
// }else{
|
|
// throw new RuntimeException("The following resource type is not managed: "+resource);
|
|
// }
|
|
// return query;
|
|
// }
|
|
//
|
|
//
|
|
// /**
|
|
// * Returns the scope list found on the more recent resource (with the same id) found at VO level
|
|
// * @param resource
|
|
// * @param vosScopes
|
|
// * @return
|
|
// */
|
|
// public static < T extends Resource> List<String> setLatestInternalScopes( T resource, HashSet<String> vosScopes){
|
|
// log.trace("setLatestInternalScopes method, voscopes "+vosScopes+", resource id: "+resource.id());
|
|
// String latestVO= getMoreRecentResourceVO(resource, vosScopes);
|
|
// if (latestVO != null)
|
|
// return extractInternalScopes(resource, latestVO);
|
|
// else return null;
|
|
// }
|
|
//
|
|
//
|
|
// private static <T extends Resource> List<String> extractInternalScopes(T resource, String latestVO) {
|
|
// T extractedResource=null;
|
|
// if(resource.type().toString().equalsIgnoreCase("RuntimeResource")){
|
|
// extractedResource= (T)ValidationUtils.getServiceEndpointByID(resource.id(), latestVO);
|
|
// }else if(resource.type().toString().equalsIgnoreCase("GenericResource")){
|
|
// extractedResource = (T)ValidationUtils.getGenericResourceByID(resource.id(), latestVO);
|
|
// }else{
|
|
// throw new RuntimeException("The following resource type is not managed: "+resource);
|
|
// }
|
|
// if(extractedResource.scopes().size() > 0){
|
|
// List<String> scopesExtracted = new ArrayList<String> (extractedResource.scopes().size());
|
|
// for(String scope: extractedResource.scopes())
|
|
// scopesExtracted.add(scope);
|
|
// return scopesExtracted;
|
|
// }
|
|
// return null;
|
|
// }
|
|
//
|
|
//
|
|
//
|
|
// /**
|
|
// * Returns the VO where the resource is the more recent resource found in the VOs
|
|
// * @param resource
|
|
// * @param vosScopes
|
|
// * @return
|
|
// */
|
|
// private static < T extends Resource> String getMoreRecentResourceVO(T resource, HashSet<String> vosScopes){
|
|
// String currentScope= ScopeProvider.instance.get();
|
|
// long timestamp=0;
|
|
// long latestTimestamp=0;
|
|
// String latestVO=null;
|
|
// try{
|
|
// for (String voScope: vosScopes){
|
|
// ScopeProvider.instance.set(voScope);
|
|
// log.debug("checking scope in "+voScope);
|
|
// List<String> timestamps = ValidationUtils.getTimestamps(resource);
|
|
// if (!timestamps.isEmpty()){
|
|
// timestamp=Long.parseLong(timestamps.get(0).toString());
|
|
// log.debug("checking "+voScope+" timestamp: "+timestamp+", with the more recent timestamp: "+latestTimestamp);
|
|
// Date date = new Date(timestamp);
|
|
// log.debug(voScope+" timestamp conversion: "+date);
|
|
// if ( timestamp > latestTimestamp){
|
|
// latestTimestamp=timestamp;
|
|
// latestVO=voScope;
|
|
// log.debug("new timestamp is "+timestamp+ " date: "+date);
|
|
// }
|
|
// }
|
|
// }
|
|
// }finally{
|
|
// // reset scope
|
|
// ScopeProvider.instance.set(currentScope);
|
|
// }
|
|
// log.debug("the vo with latest timestamp is " +latestVO);
|
|
// log.debug("timestamp is " +latestTimestamp);
|
|
// return latestVO;
|
|
// }
|
|
|
|
|
|
}
|