Update pom.xml

Updated for gCubeRelease 6.0.0

.settings/.gitignore

@@ -0,0 +1,2 @@
+/org.eclipse.ltk.core.refactoring.prefs
+/org.eclipse.wst.xsl.core.prefs

.settings/org.eclipse.jdt.core.prefs

@@ -1,15 +1,109 @@
 eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.annotation.inheritNullAnnotations=disabled
+org.eclipse.jdt.core.compiler.annotation.missingNonNullByDefaultAnnotation=ignore
+org.eclipse.jdt.core.compiler.annotation.nonnull=org.eclipse.jdt.annotation.NonNull
+org.eclipse.jdt.core.compiler.annotation.nonnull.secondary=
+org.eclipse.jdt.core.compiler.annotation.nonnullbydefault=org.eclipse.jdt.annotation.NonNullByDefault
+org.eclipse.jdt.core.compiler.annotation.nonnullbydefault.secondary=
+org.eclipse.jdt.core.compiler.annotation.nullable=org.eclipse.jdt.annotation.Nullable
+org.eclipse.jdt.core.compiler.annotation.nullable.secondary=
+org.eclipse.jdt.core.compiler.annotation.nullanalysis=disabled
 org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate
 org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
 org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
 org.eclipse.jdt.core.compiler.compliance=1.8
 org.eclipse.jdt.core.compiler.debug.lineNumber=generate
 org.eclipse.jdt.core.compiler.debug.localVariable=generate
 org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning
 org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.autoboxing=ignore
+org.eclipse.jdt.core.compiler.problem.comparingIdentical=warning
+org.eclipse.jdt.core.compiler.problem.deadCode=warning
+org.eclipse.jdt.core.compiler.problem.deprecation=warning
+org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled
+org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled
+org.eclipse.jdt.core.compiler.problem.discouragedReference=warning
+org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore
 org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
 org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=ignore
+org.eclipse.jdt.core.compiler.problem.fallthroughCase=ignore
+org.eclipse.jdt.core.compiler.problem.fatalOptionalError=disabled
+org.eclipse.jdt.core.compiler.problem.fieldHiding=ignore
+org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning
+org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning
 org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
+org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning
+org.eclipse.jdt.core.compiler.problem.includeNullInfoFromAsserts=disabled
+org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning
+org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=warning
+org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore
+org.eclipse.jdt.core.compiler.problem.localVariableHiding=ignore
+org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning
+org.eclipse.jdt.core.compiler.problem.missingDefaultCase=ignore
+org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=ignore
+org.eclipse.jdt.core.compiler.problem.missingEnumCaseDespiteDefault=disabled
+org.eclipse.jdt.core.compiler.problem.missingHashCodeMethod=ignore
+org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=ignore
+org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotationForInterfaceMethodImplementation=enabled
+org.eclipse.jdt.core.compiler.problem.missingSerialVersion=warning
+org.eclipse.jdt.core.compiler.problem.missingSynchronizedOnInheritedMethod=ignore
+org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning
+org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning
+org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=ignore
+org.eclipse.jdt.core.compiler.problem.nonnullParameterAnnotationDropped=warning
+org.eclipse.jdt.core.compiler.problem.nonnullTypeVariableFromLegacyInvocation=warning
+org.eclipse.jdt.core.compiler.problem.nullAnnotationInferenceConflict=error
+org.eclipse.jdt.core.compiler.problem.nullReference=warning
+org.eclipse.jdt.core.compiler.problem.nullSpecViolation=error
+org.eclipse.jdt.core.compiler.problem.nullUncheckedConversion=warning
+org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning
+org.eclipse.jdt.core.compiler.problem.parameterAssignment=ignore
+org.eclipse.jdt.core.compiler.problem.pessimisticNullAnalysisForFreeTypeVariables=warning
+org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=ignore
+org.eclipse.jdt.core.compiler.problem.potentialNullReference=ignore
+org.eclipse.jdt.core.compiler.problem.potentiallyUnclosedCloseable=ignore
+org.eclipse.jdt.core.compiler.problem.rawTypeReference=warning
+org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation=warning
+org.eclipse.jdt.core.compiler.problem.redundantNullCheck=ignore
+org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=ignore
+org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=ignore
+org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic=ignore
+org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic=ignore
 org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=ignore
+org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled
+org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning
+org.eclipse.jdt.core.compiler.problem.suppressOptionalErrors=disabled
+org.eclipse.jdt.core.compiler.problem.suppressWarnings=enabled
+org.eclipse.jdt.core.compiler.problem.syntacticNullAnalysisForFields=disabled
+org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore
+org.eclipse.jdt.core.compiler.problem.typeParameterHiding=warning
+org.eclipse.jdt.core.compiler.problem.unavoidableGenericTypeProblems=enabled
+org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=warning
+org.eclipse.jdt.core.compiler.problem.unclosedCloseable=warning
+org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=ignore
+org.eclipse.jdt.core.compiler.problem.unhandledWarningToken=warning
+org.eclipse.jdt.core.compiler.problem.unnecessaryElse=ignore
+org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=ignore
+org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore
+org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=ignore
+org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionExemptExceptionAndThrowable=enabled
+org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference=enabled
+org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled
+org.eclipse.jdt.core.compiler.problem.unusedExceptionParameter=ignore
+org.eclipse.jdt.core.compiler.problem.unusedImport=warning
+org.eclipse.jdt.core.compiler.problem.unusedLabel=warning
+org.eclipse.jdt.core.compiler.problem.unusedLocal=warning
+org.eclipse.jdt.core.compiler.problem.unusedObjectAllocation=ignore
+org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore
+org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocCommentReference=enabled
+org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled
+org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled
+org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=warning
+org.eclipse.jdt.core.compiler.problem.unusedTypeParameter=ignore
+org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning
+org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
 org.eclipse.jdt.core.compiler.release=disabled
 org.eclipse.jdt.core.compiler.source=1.8

CHANGELOG.md

@@ -3,76 +3,74 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 # Changelog for "dataminer"
 
 
-## [v1.7.1] - 2021-05-24
+## [v1.9.1]
 
-### Fixes
+- Updated gcube-bom to 2.4.1
+
+
+## [v1.9.0] - 2022-04-05
+
+-  Added support to  new JWT token via URI Resolver [#23107]
+
+
+## [v1.8.1] - 2022-03-21
+
+- Update wps service to support not writing of the computation status to the user's workspace [#23054]
+- Fixed protocol parameter when persistence is disabled
+
+
+## [v1.8.0] - 2022-01-24
+
+- Fixed max computations support [#22700]
+
+
+## [v1.7.1] - 2021-05-24
 
 - Fixed obsolete short urls [#20971]
 
 
 ## [v1.7.0] - 2020-11-20
 
-### Fixes
-
 - import range modified to resolve old repositories invalid url
 
-## [v1.6.0] - 2020-05-12
 
-### Fixes
+## [v1.6.0] - 2020-05-12
 
 - Added storagehub retry in InputsManager class, getLocalFile method [#19253]
 
 
-
 ## [v1.5.9] - 2019-11-20
 
-### Fixes
-
 - Fixed Content-Type support for files in the results of computations [#18096]
 
 
-
 ## [v1.5.8] - 2019-10-01
 
-### Fixes
-
 - Fixed https link for output parameter [#17659]
 
 
-
 ## [v1.5.7] - 2019-03-01
 
-### Features
-
 - Updated https support [#13024]
 
 
 
 ## [v1.5.2] - 2017-12-13
 
-### Fixes
-
 - added the right extension on output file
 - lock file created on execution
 
 
-
 ## [v1.5.1] - 2017-09-14
 
-### Features
-
 - added accounting on algorithm execution
 
 
-
 ## [v1.5.0] - 2017-07-31
 
-### Features
-
 - service interface classes moved to wps project
 
 
-
 ## [v1.1.0] - 2016-10-03
 
 - First Release

pom.xml

@@ -1,15 +1,16 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 	<modelVersion>4.0.0</modelVersion>
 	<parent>
 		<artifactId>maven-parent</artifactId>
 		<groupId>org.gcube.tools</groupId>
-		<version>1.1.0</version>
+		<version>1.2.0</version>
 		<relativePath />
 	</parent>
 	<groupId>org.gcube.dataanalysis</groupId>
 	<artifactId>dataminer</artifactId>
-	<version>1.7.1</version>
+	<version>1.9.1</version>
 	<name>dataminer</name>
 	<description>An e-Infrastructure service providing state-of-the art DataMining algorithms and ecological modelling approaches under the Web Processing Service (WPS) standard.</description>
 
@@ -21,7 +22,7 @@
 
 	<developers>
 		<developer>
-			<name>Gianpaolo Coro</name>
+			<name>Gianpaolo 52n-wps-io-implCoro</name>
 			<email>gianpaolo.coro@isti.cnr.it</email>
 			<organization>CNR Pisa, Istituto di Scienza e Tecnologie dell'Informazione "A. Faedo"</organization>
 			<roles>
@@ -55,7 +56,7 @@
 			<dependency>
 				<groupId>org.gcube.distribution</groupId>
 				<artifactId>gcube-bom</artifactId>
-				<version>2.0.1</version>
+				<version>2.4.1</version>
 				<type>pom</type>
 				<scope>import</scope>
 			</dependency>
@@ -91,12 +92,12 @@
 		<dependency>
 			<groupId>org.gcube.dataanalysis</groupId>
 			<artifactId>52n-wps-algorithm-gcube</artifactId>
-			<version>[3.6.1,3.7.0)</version>
+			<version>[3.6.1,3.7.0-SNAPSHOT)</version>
 		</dependency>
 		<dependency>
 			<groupId>org.gcube.dataanalysis</groupId>
 			<artifactId>52n-wps-server-gcube</artifactId>
-			<version>[3.6.1, 3.7.0)</version>
+			<version>[3.6.1, 3.7.0-SNAPSHOT)</version>
 		</dependency>
 		<dependency>
 			<groupId>org.gcube.dataanalysis</groupId>
@@ -106,7 +107,7 @@
 		<dependency>
 			<groupId>org.gcube.dataanalysis</groupId>
 			<artifactId>ecological-engine-geospatial-extensions</artifactId>
-			<version>[1.5.2-SNAPSHOT,2.0.0-SNAPSHOT)</version>
+			<version>[1.5.2,2.0.0-SNAPSHOT)</version>
 			<exclusions>
 				<exclusion>
 					<artifactId>log4j</artifactId>
@@ -117,12 +118,12 @@
 		<dependency>
 			<groupId>org.gcube.dataanalysis</groupId>
 			<artifactId>ecological-engine-external-algorithms</artifactId>
-			<version>[1.2.2-SNAPSHOT,2.0.0-SNAPSHOT)</version>
+			<version>[1.2.2,2.0.0-SNAPSHOT)</version>
 		</dependency>
 		<dependency>
 			<groupId>org.gcube.dataanalysis</groupId>
 			<artifactId>ecological-engine-smart-executor</artifactId>
-			<version>[1.6.5-SNAPSHOT,2.0.0-SNAPSHOT)</version>
+			<version>[1.6.5,2.0.0-SNAPSHOT)</version>
 			<exclusions>
 				<exclusion>
 					<groupId>org.glassfish.jersey.core</groupId>
@@ -145,6 +146,7 @@
 				</exclusion>
 			</exclusions>
 		</dependency>
+
 		<dependency>
 			<groupId>junit</groupId>
 			<artifactId>junit</artifactId>
@@ -162,12 +164,10 @@
 		<dependency>
 			<groupId>org.gcube.common</groupId>
 			<artifactId>storagehub-client-library</artifactId>
-			<version>[1.0.0, 2.0.0-SNAPSHOT)</version>
 		</dependency>
 		<dependency>
 			<groupId>org.gcube.common</groupId>
 			<artifactId>storagehub-model</artifactId>
-			<version>[1.0.0, 2.0.0-SNAPSHOT)</version>
 		</dependency>
 
 		<dependency>
@@ -201,7 +201,7 @@
 		<repository>
 			<id>n52-releases</id>
 			<name>52n Releases</name>
-			<url>http://52north.org/maven/repo/releases</url>
+			<url>https://52north.org/maven/repo/releases</url>
 			<releases>
 				<enabled>true</enabled>
 			</releases>

src/main/java/org/gcube/dataanalysis/wps/statisticalmanager/synchserver/is/InformationSystemUtils.java

@@ -0,0 +1,67 @@
+package org.gcube.dataanalysis.wps.statisticalmanager.synchserver.is;
+
+import java.util.List;
+
+import org.gcube.common.resources.gcore.ServiceEndpoint;
+import org.gcube.common.resources.gcore.ServiceEndpoint.Runtime;
+import org.gcube.common.scope.api.ScopeProvider;
+import org.gcube.resources.discovery.client.api.DiscoveryClient;
+import org.gcube.resources.discovery.client.queries.api.SimpleQuery;
+import org.gcube.resources.discovery.icclient.ICFactory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class InformationSystemUtils {
+
+	private static final Logger LOGGER = LoggerFactory.getLogger(InformationSystemUtils.class);
+	private static final String URI_RESOLVER_SERVICE_CATEGORY = "Service";
+	private static final String URI_RESOLVER_SERVICE_NAME = "HTTP-URI-Resolver";
+
+	public static String retrieveUriResolverOat(String scope) throws Exception {
+		try {
+			LOGGER.info("Retrieve URI Resolver Oat Service Info");
+
+			if (scope == null || scope.length() == 0) {
+				String error="Invalid request scope: " + scope;
+				LOGGER.error(error);
+				throw new Exception(error);
+			}
+
+			ScopeProvider.instance.set(scope);
+
+			SimpleQuery query = ICFactory.queryFor(ServiceEndpoint.class);
+			query.addCondition("$resource/Profile/Category/text() eq '" + URI_RESOLVER_SERVICE_CATEGORY + "'")
+					.addCondition("$resource/Profile/Name/text() eq '" + URI_RESOLVER_SERVICE_NAME + "'")
+					.setResult("$resource/Profile/RunTime");
+			DiscoveryClient<Runtime> client = ICFactory.clientFor(Runtime.class);
+		
+			List<Runtime> runtimeList = client.submit(query);
+			String serviceAddress = null;
+			if (runtimeList != null && !runtimeList.isEmpty()) {
+				for (int i = 0; i < runtimeList.size(); i++) {
+					Runtime accessPoint = runtimeList.get(i);
+					if (accessPoint != null) {
+						StringBuilder sb=new StringBuilder();
+						sb.append("https://");
+						sb.append(accessPoint.hostedOn());
+						sb.append("/oat/get");
+						serviceAddress=sb.toString();
+						break;
+					}
+				}
+			} else {
+				String error="RuntimeList error: "+runtimeList;
+				LOGGER.error(error);
+				throw new Exception(error);
+			}
+
+			LOGGER.info("Uri Resolver Oat Service Info: " + serviceAddress);
+			return serviceAddress;
+
+		} catch (Throwable e) {
+			LOGGER.error("Error in discovery Uri Resolver Oat Service Endpoint in scope: " + scope);
+			LOGGER.error(e.getLocalizedMessage(),e);
+			throw e;
+		}
+	}
+}

src/main/java/org/gcube/dataanalysis/wps/statisticalmanager/synchserver/mapping/AbstractEcologicalEngineMapper.java

@@ -50,13 +50,14 @@ import org.slf4j.LoggerFactory;
 
 public class AbstractEcologicalEngineMapper extends AbstractAnnotatedAlgorithm implements Observable, Cancellable {
 
+	private static final int COMPUTATION_WAIT_FOR_RUN_REQUEST = 20000;
+
 	/**
-	 * Deploying procedure: 1 - modify configuration files 2 - modify resource
+	 * Deploying procedure: 1 - modify configuration files 2 - modify resource file:
-	 * file: resources/templates/setup.cfg 3 - generate classes with
+	 * resources/templates/setup.cfg 3 - generate classes with ClassGenerator 4 -
-	 * ClassGenerator 4 - add new classes in the wps_config.xml on the wps web
+	 * add new classes in the wps_config.xml on the wps web app config folder 5 -
-	 * app config folder 5 - produce the Jar file of this project 6 - copy the
+	 * produce the Jar file of this project 6 - copy the jar file in the lib folder
-	 * jar file in the lib folder of the wps web app change the server
+	 * of the wps web app change the server parameters in the wps_config.xml file
-	 * parameters in the wps_config.xml file
 	 */
 
 	private static final Logger LOGGER = LoggerFactory.getLogger(AbstractEcologicalEngineMapper.class);
@@ -85,30 +86,41 @@ public class AbstractEcologicalEngineMapper extends AbstractAnnotatedAlgorithm i
 		this.wpsExternalID = wpsExternalID;
 	}
 
-	public static synchronized void addComputation(String session, String user) {
+	private static synchronized void addComputation(String session, String user) {
 		runningcomputations.put(session, user);
 	}
 
-	public static synchronized void removeComputation(String session) {
+	private static synchronized void removeComputation(String session) {
 		runningcomputations.remove(session);
 	}
 
-	public static synchronized int getRuningComputations() {
+	private static synchronized int getRuningComputations() {
 		return runningcomputations.size();
 	}
 
-	public static synchronized String displayRunningComputations() {
+	private static synchronized String displayRunningComputations() {
 		return runningcomputations.toString();
 	}
 
-	public void waitForResources() throws Exception {
+	private void waitForResources(String computationSession, String username, String scope) throws Exception {
-		while (getRuningComputations() > ConfigurationManager.getMaxComputations()) {
+		while (waitCondition(computationSession, username, scope)) {
-			Thread.sleep(20000);
+			Thread.sleep(COMPUTATION_WAIT_FOR_RUN_REQUEST);
 			LOGGER.debug("Waiting for resources to be available: " + displayRunningComputations());
 		}
 
 	}
 
+	private static synchronized boolean waitCondition(String computationSession, String username, String scope) {
+		if (getRuningComputations() >= ConfigurationManager.getMaxComputations()) {
+			return true;
+		} else {
+			// add the computation to the global list of computations
+			LOGGER.debug("Add computation to run: {}", computationSession);
+			addComputation(computationSession, username + ":" + scope);
+			return false;
+		}
+	}
+
 	// inner objects
 	public AlgorithmConfiguration config;
 	public InfrastructureDialoguer infrastructureDialoguer;
@@ -366,11 +378,9 @@ public class AbstractEcologicalEngineMapper extends AbstractAnnotatedAlgorithm i
 			config = configManager.getConfig();
 			LOGGER.info("Configured algorithm with session " + computationSession);
 			time("Configuration");
-			waitForResources();
+			waitForResources(computationSession, configManager.getUsername(), configManager.getScope());
 			LOGGER.info("Running algorithm with session " + computationSession);
 			time("Waiting time for resources to be free");
-			// add the computation to the global list of computations
-			addComputation(computationSession, configManager.getUsername() + ":" + configManager.getScope());
 
 			String scope = configManager.getScope();
 			String username = configManager.getUsername();
@@ -502,8 +512,8 @@ public class AbstractEcologicalEngineMapper extends AbstractAnnotatedAlgorithm i
 				throw e;
 		} finally {
 			LOGGER.debug("accounting algorithm");
-			if(operationResult==null){
+			if (operationResult == null) {
-				operationResult=OperationResult.FAILED;
+				operationResult = OperationResult.FAILED;
 			}
 			accountAlgorithmExecution(startTimeLong, System.currentTimeMillis(), operationResult);
 			LOGGER.debug("Deleting Input Tables");
@@ -527,15 +537,25 @@ public class AbstractEcologicalEngineMapper extends AbstractAnnotatedAlgorithm i
 	}
 
 	private boolean checkWriteAuthorization(String username) {
-		if (env != null && env.getShubUsersExcluded() != null) {
+		if (env != null) {
-			if (env.getShubUsersExcluded().isEmpty()) {
+			if (env.getShubUsersExcluded() != null) {
-				return false;
+				if (env.getShubUsersExcluded().isEmpty()) {
-			}
+					// all users write
-			if (env.getShubUsersExcluded().contains(username)) {
+					return true;
+				}
+				if (env.getShubUsersExcluded().contains(username)) {
+					return false;
+				} else {
+					// username write
+					return true;
+				}
+			} else {
+				//This is the * case, no users write.
 				return false;
 			}
+		} else {
+			return false;
 		}
-		return true;
 	}
 
 	private void accountAlgorithmExecution(long start, long end, OperationResult result) {

src/main/java/org/gcube/dataanalysis/wps/statisticalmanager/synchserver/mapping/ConfigurationManager.java

@@ -22,25 +22,24 @@ public class ConfigurationManager {
 	public static String usernameParameter = "user.name";
 	public static String scopeParameter = "scope";
 	public static String tokenParameter = "usertoken";
-	public static String defaultScope= "/gcube/devsec";
+	public static String defaultScope = "/gcube/devsec";
-	public static String defaultUsername= "statistical.wps";
+	public static String defaultUsername = "statistical.wps";
 
 	private static Integer maxComputations = null;
 	private static Boolean useStorage = null;
 	static boolean simulationMode = false;
 
-
 	EnvironmentVariableManager env = null;
 
-	public static synchronized Integer getMaxComputations(){
+	public static synchronized Integer getMaxComputations() {
 		return maxComputations;
 	}
 
-	public static synchronized Boolean useStorage(){
+	public static synchronized Boolean useStorage() {
 		return useStorage;
 	}
 
-	public static synchronized Boolean isSimulationMode(){
+	public static synchronized Boolean isSimulationMode() {
 		return simulationMode;
 	}
 
@@ -57,12 +56,12 @@ public class ConfigurationManager {
 				options.load(is);
 				is.close();
 				maxComputations = Integer.parseInt(options.getProperty("maxcomputations"));
-				logger.info("setting max computation to {}",maxComputations);
+				logger.info("setting max computation to {}", maxComputations);
 				useStorage = Boolean.parseBoolean(options.getProperty("saveond4sstorage"));
-				simulationMode=Boolean.parseBoolean(options.getProperty("simulationMode"));
+				simulationMode = Boolean.parseBoolean(options.getProperty("simulationMode"));
 			}
 		} catch (Exception e) {
-			logger.error("error initializing properties",e);
+			logger.error("error initializing properties", e);
 		}
 	}
 
@@ -80,7 +79,8 @@ public class ConfigurationManager {
 	}
 
 	public ConfigurationManager(EnvironmentVariableManager env) {
-		if (env == null) inizializePropertiesUsingTemplateFile();
+		if (env == null)
+			inizializePropertiesUsingTemplateFile();
 		else {
 			maxComputations = env.getMaxComputation();
 			useStorage = env.isSaveOnStorage();
@@ -92,7 +92,7 @@ public class ConfigurationManager {
 		return config;
 	}
 
-	public void setComputationId(String computationId){
+	public void setComputationId(String computationId) {
 		config.setTaskID(computationId);
 	}
 
@@ -109,28 +109,30 @@ public class ConfigurationManager {
 			persistencePath = "./";
 		}
 		logger.debug("Taking configuration from  {}", configPath);
-		//+ " and persistence in " + persistencePath);
+		// + " and persistence in " + persistencePath);
 		// setting configuration and logger
 		config.setPersistencePath(configPath);
 		config.setConfigPath(configPath);
 		config.setNumberOfResources(1);
 		// setting application paths
+		String protocol = WPSConfig.getInstance().getWPSConfig().getServer().getProtocol();
 		String webapp = WPSConfig.getInstance().getWPSConfig().getServer().getWebappPath();
 		String host = WPSConfig.getInstance().getWPSConfig().getServer().getHostname();
 		String port = WPSConfig.getInstance().getWPSConfig().getServer().getHostport();
-		logger.debug("Host: {}  Port: {} Webapp: {} ", host, port, webapp );
+		logger.debug("Protocol: {} , Host: {} , Port: {} , Webapp: {} ", protocol, host, port, webapp);
-		logger.debug("Web persistence path:{} ", webperspath);
+		logger.info("Web Path Persistence: {}", webperspath);
 
-		String webPath = "http://" + host + ":" + port + "/" + webapp + "/persistence/";
+		String webPath = protocol + "://" + host + ":" + port + "/" + webapp + "/persistence/";
 
 		// logger.debug("Env Vars: \n"+System.getenv());
-		logger.debug("Web app path: {} ",  webPath);
+		logger.info("Web Path Persistence Url: {}", webPath);
 
 		// retrieving scope
 		scope = (String) inputs.get(scopeParameter);
-		logger.debug("Retrieved scope: {} ",  scope);
+		logger.debug("Retrieved scope: {} ", scope);
 		if (scope == null)
-			throw new Exception("Error: scope parameter (scope) not set! This violates e-Infrastructure security policies");
+			throw new Exception(
+					"Error: scope parameter (scope) not set! This violates e-Infrastructure security policies");
 		if (!scope.startsWith("/"))
 			scope = "/" + scope;
 
@@ -141,7 +143,8 @@ public class ConfigurationManager {
 		logger.debug("User token used by the client:{} ", token);
 
 		if (username == null || username.trim().length() == 0)
-			throw new Exception("Error: user name parameter (user.name) not set! This violates e-Infrastructure security policies");
+			throw new Exception(
+					"Error: user name parameter (user.name) not set! This violates e-Infrastructure security policies");
 
 		if (token == null || token.trim().length() == 0)
 			throw new Exception("Error: token parameter not set! This violates e-Infrastructure security policies");

src/main/java/org/gcube/dataanalysis/wps/statisticalmanager/synchserver/mapping/TokenManager.java

@@ -2,30 +2,42 @@ package org.gcube.dataanalysis.wps.statisticalmanager.synchserver.mapping;
 
 import static org.gcube.common.authorization.client.Constants.authorizationService;
 
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.HttpURLConnection;
+import java.net.URL;
+
+import javax.ws.rs.core.Response;
+
 import org.gcube.common.authorization.library.AuthorizationEntry;
+import org.gcube.common.authorization.library.provider.AccessTokenProvider;
 import org.gcube.common.authorization.library.provider.AuthorizationProvider;
 import org.gcube.common.authorization.library.provider.SecurityTokenProvider;
+import org.gcube.common.scope.api.ScopeProvider;
+import org.gcube.dataanalysis.wps.statisticalmanager.synchserver.is.InformationSystemUtils;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 public class TokenManager {
 
-	private static final Logger LOGGER= LoggerFactory.getLogger(TokenManager.class);
+	private static final Logger LOGGER = LoggerFactory.getLogger(TokenManager.class);
 
 	String username;
 	String scope;
 	String token;
 	String tokenQualifier;
 
-	public String getScope(){
+	public String getScope() {
 		return scope;
 	}
 
-	public String getUserName(){
+	public String getUserName() {
 		return username;
 	}
 
-	public String getToken(){
+	public String getToken() {
 		return token;
 	}
 
@@ -34,27 +46,78 @@ public class TokenManager {
 	}
 
 	public void getCredentials() {
-		try{
+		try {
-			LOGGER.debug("Retrieving token credentials");
+			LOGGER.info("Retrieving token credentials");
-			//get username from SmartGears
+			// get username from SmartGears
 			username = AuthorizationProvider.instance.get().getClient().getId();
 			token = SecurityTokenProvider.instance.get();
+			if (token == null || token.isEmpty()) {
+				String jwtToken = AccessTokenProvider.instance.get();
+				scope = ScopeProvider.instance.get();
+				token = getGcubeTokenFromUriResolver(jwtToken, scope);
+			}
 			AuthorizationEntry entry = authorizationService().get(token);
 			scope = entry.getContext();
 			tokenQualifier = entry.getQualifier();
-
+		} catch (Exception e) {
-		}catch(Exception e){
+			LOGGER.error("Error Retrieving token credentials: "+e.getLocalizedMessage(),e);
-			LOGGER.error("Error Retrieving token credentials ",e);
 			scope = null;
-			username= null;
+			username = null;
 
 		}
-		if ((scope==null || username==null) && ConfigurationManager.isSimulationMode()){
+		if ((scope == null || username == null) && ConfigurationManager.isSimulationMode()) {
 			scope = ConfigurationManager.defaultScope;
 			username = ConfigurationManager.defaultUsername;
 		}
-		LOGGER.debug("Retrieved scope: {} Username: {} Token {} SIMULATION MODE: {} ",scope, username, token, ConfigurationManager.isSimulationMode());
+		LOGGER.info("Retrieved scope: {} Username: {} Token {} SIMULATION MODE: {} ", scope, username, token,
+				ConfigurationManager.isSimulationMode());
 
 	}
 
+	public String getGcubeTokenFromUriResolver(String jwtToken, String scope) throws Exception {
+		String gcubeToken = null;
+		String uriResolverOatURL = InformationSystemUtils.retrieveUriResolverOat(scope);
+		try {
+			LOGGER.info("Create Request: "+ uriResolverOatURL);
+			URL urlObj = new URL(uriResolverOatURL);
+			HttpURLConnection connection = (HttpURLConnection) urlObj.openConnection();
+			connection.setRequestMethod("GET");
+			connection.setRequestProperty("Authorization", "Bearer " + jwtToken);
+			connection.setDoOutput(true);
+			try (AutoCloseable conc = () -> connection.disconnect()) {
+				int responseCode = connection.getResponseCode();
+				LOGGER.info("Response Code: " + responseCode);
+				
+				if (Response.Status.fromStatusCode(responseCode).compareTo(Response.Status.OK) == 0) {
+					try (InputStream ins = connection.getInputStream();
+							BufferedReader in = new BufferedReader(new InputStreamReader(ins))) {
+						String inputLine = null;
+						while ((inputLine = in.readLine()) != null) {
+							break;
+						}
+						gcubeToken = inputLine;
+					}
+				} else {
+					String error = "Invalid Response Code retrieving GCube Token from Uri Resolver: " + responseCode;
+					LOGGER.error(error);
+					try (InputStream ins = connection.getErrorStream();
+							BufferedReader in = new BufferedReader(new InputStreamReader(ins))) {
+						String inputLine = null;
+						while ((inputLine = in.readLine()) != null) {
+							LOGGER.error(inputLine);
+						}
+					}
+					throw new Exception(error);
+				}
+			}
+
+		} catch (IOException e) {
+			LOGGER.error("Error retrieving GcubeToken from Uri Resolver: "+e.getLocalizedMessage());
+			e.printStackTrace();
+			throw e;
+		}
+		LOGGER.info("Retrieved GcubeToken: "+gcubeToken);
+		return gcubeToken;
+	}
+
 }

src/main/java/org/gcube/dataanalysis/wps/statisticalmanager/synchserver/mapping/dataspace/DataspaceManager.java

@@ -64,7 +64,7 @@ public class DataspaceManager implements Runnable {
 	public static String payload = "payload";
 
 	private String statusComputationName;
-	private static final String STATUS_POSTFIX="-STATUS";
+	private static final String STATUS_POSTFIX = "-STATUS";
 
 	public DataspaceManager(AlgorithmConfiguration config, ComputationData computation, List<StoredData> inputData,
 			List<StoredData> outputData, List<File> generatedFiles) {
@@ -73,7 +73,7 @@ public class DataspaceManager implements Runnable {
 		this.inputData = inputData;
 		this.outputData = outputData;
 		this.generatedFiles = generatedFiles;
-		this.statusComputationName =  this.computation.id+STATUS_POSTFIX;
+		this.statusComputationName = this.computation.id + STATUS_POSTFIX;
 
 		LOGGER.debug("DataspaceManager [config=" + config + ", computation=" + computation + ", inputData=" + inputData
 				+ ", outputData=" + outputData + ", generatedFiles=" + generatedFiles + "]");
@@ -142,25 +142,26 @@ public class DataspaceManager implements Runnable {
 	}
 
 	public String uploadData(StoredData data, FolderContainer destinationFolder, boolean changename) throws Exception {
-		LOGGER.debug("Dataspace->Analysing " + data);
+		LOGGER.debug("Dataspace->Uploaddata:"
+				+ " [data={},destinationFolder={}, changename={}] ", data, destinationFolder,
+				changename);
 		// String filenameonwsString = WorkspaceUtil.getUniqueName(data.name,
 		// wsFolder);
 		String filenameonwsString = data.name;
 		if (changename)
-			filenameonwsString = String.format("%s_(%s)%s", data.name, data.computationId,
+			filenameonwsString = String.format("%s_(%s)%s", data.name, data.computationId, getExtension(data.payload));
-					getExtension(data.payload));
 
 		InputStream in = null;
 		String url = "";
 		try {
-			//long size = 0;
+			// long size = 0;
 			if (data.type.equals("text/csv") || data.type.equals("application/d4science")
 					|| data.type.equals("image/png")) {
 
 				if (new File(data.payload).exists() || !data.payload.startsWith("http")) {
 					LOGGER.debug("Dataspace->Uploading file {}", data.payload);
 					in = new FileInputStream(new File(data.payload));
-					//size = new File(data.payload).length();
+					// size = new File(data.payload).length();
 				} else {
 					LOGGER.debug("Dataspace->Uploading via URL {}", data.payload);
 					int tries = 10;
@@ -188,7 +189,7 @@ public class DataspaceManager implements Runnable {
 
 				// LOGGER.debug("Dataspace->final file name on ws " +
 				// data.name+" description "+data.description);
-				LOGGER.debug("Dataspace->WS OP saving the following file on the WS " + filenameonwsString);
+				LOGGER.debug("Dataspace->WS OP saving the following file on the WS: " + filenameonwsString);
 				Map<String, Object> properties = new LinkedHashMap<String, Object>();
 
 				properties.put(computation_id, data.computationId);
@@ -203,9 +204,11 @@ public class DataspaceManager implements Runnable {
 				properties.put(payload, url);
 
 				FileContainer fileContainer = destinationFolder.uploadFile(in, filenameonwsString, data.description);
-				fileContainer.setMetadata(new Metadata(properties));
+				LOGGER.debug("Dataspace->WS OP file uploaded on WS: " + filenameonwsString);
+				Metadata metadata = new Metadata(properties);
+				fileContainer.setMetadata(metadata);
 
-				LOGGER.debug("Dataspace->WS OP file saved on the WS " + filenameonwsString);
+				LOGGER.debug("Dataspace->WS OP file set metadata: " + metadata);
 
 				url = fileContainer.getPublicLink().toString();
 				LOGGER.debug("Dataspace->WS OP url produced for the file " + url);
@@ -395,10 +398,9 @@ public class DataspaceManager implements Runnable {
 		}
 		/*
 		 * List<String> scopes = new ArrayList<String>();
-		 * scopes.add(config.getGcubeScope());
+		 * scopes.add(config.getGcubeScope()); ws.createGcubeItem(computation.id,
-		 * ws.createGcubeItem(computation.id, computation.operatorDescription,
+		 * computation.operatorDescription, scopes, computation.user, itemType,
-		 * scopes, computation.user, itemType, properties,
+		 * properties, newcomputationFolder.getId());
-		 * newcomputationFolder.getId());
 		 */
 		newcomputationFolder.setMetadata(new Metadata(properties));
 
@@ -466,7 +468,7 @@ public class DataspaceManager implements Runnable {
 		List<String> scopes = new ArrayList<String>();
 		scopes.add(config.getGcubeScope());
 
-		//TODO: update gcubeItem not recreate it...
+		// TODO: update gcubeItem not recreate it...
 		GCubeItem gcubeItem = new GCubeItem();
 		gcubeItem.setName(this.statusComputationName);
 		gcubeItem.setDescription(computation.operatorDescription);
@@ -509,7 +511,8 @@ public class DataspaceManager implements Runnable {
 				.getContainers().get(0);
 		LOGGER.debug("Dataspace->removing computation data");
 
-		List<ItemContainer<? extends Item>> wi = computationContainer.findByName(this.statusComputationName).getContainers();
+		List<ItemContainer<? extends Item>> wi = computationContainer.findByName(this.statusComputationName)
+				.getContainers();
 		if (!wi.isEmpty()) {
 			for (ItemContainer<? extends Item> container : wi) {
 				boolean retry = false;
@@ -517,25 +520,23 @@ public class DataspaceManager implements Runnable {
 					try {
 						container.forceDelete();
 						retry = false;
-					}catch (ItemLockedException e) {
+					} catch (ItemLockedException e) {
 						LOGGER.warn("item locked, retrying");
 						Thread.sleep(1000);
 						retry = true;
 					}
-				}while (retry);
+				} while (retry);
 			}
 		} else
 			LOGGER.debug("Dataspace->Warning Could not find {} under {}", this.statusComputationName,
 					computationContainer.get().getName());
 
-
 		/*
 		 * TODO: ASK GIANPAOLO int maxtries = 3; int i =1; while
-		 * (ws.exists(computation.id,computationsFolderWs.getId()) &&
+		 * (ws.exists(computation.id,computationsFolderWs.getId()) && i<maxtries){
-		 * i<maxtries){
+		 * LOGGER.debug("Dataspace->computation data still exist... retrying "+i );
-		 * LOGGER.debug("Dataspace->computation data still exist... retrying "+i
+		 * Thread.sleep(1000); computationsFolderWs.find(computation.id).remove(); i++;
-		 * ); Thread.sleep(1000);
+		 * }
-		 * computationsFolderWs.find(computation.id).remove(); i++; }
 		 */
 
 		LOGGER.debug("Dataspace->finished removing computation data ");
@@ -544,7 +545,7 @@ public class DataspaceManager implements Runnable {
 	// TODO
 	public static String getExtension(String payload) {
 		LOGGER.debug("DataSpace->Get Extension from: " + payload);
-		String extension="";
+		String extension = "";
 		if (payload.toLowerCase().startsWith("http")) {
 			try {
 				URL obj = new URL(payload);

src/test/java/org/gcube/dataanalysis/wps/statisticalmanager/synchserver/mapping/TokenManagerTest.java

@@ -0,0 +1,26 @@
+package org.gcube.dataanalysis.wps.statisticalmanager.synchserver.mapping;
+
+import org.apache.log4j.BasicConfigurator;
+import org.junit.Test;
+
+public class TokenManagerTest {
+
+	private static final String JWT_TOKEN = "";
+	private static final String SCOPE = "/gcube/devsec/devVRE";
+
+	
+	@Test
+	public void retrieveTokenFromUriResolver() throws Exception {
+		try {
+			BasicConfigurator.configure();
+			System.out.println("Test Retrieve Token From Uri Resolver");
+			TokenManager tm = new TokenManager();
+			String token = tm.getGcubeTokenFromUriResolver(JWT_TOKEN, SCOPE);
+			System.out.println("GcubeToken retrieved: "+token);
+		} catch (Exception e) {
+			System.out.println(e.getLocalizedMessage());
+			e.getStackTrace();
+		}
+	}
+
+}

src/test/java/org/gcube/dataanalysis/wps/statisticalmanager/synchserver/test/AlgorithmTest.java

@@ -30,7 +30,7 @@ public class AlgorithmTest {
 		
 		String protocol = "http";
 		String hostname = "dataminer-genericworkers.d4science.org";
-		String token = "257800d8-24bf-4bae-83cd-ea99369e7dd6-843339462";
+		String token = "xxx-xxx-xxx-xxx";
 		String layerID = "08ee0d70-4d8b-4f42-8b06-d709482bca95";
 						 
 		Iterator<String> uris =  getUrisIterator();