diff --git a/.classpath b/.classpath
new file mode 100644
index 0000000..82422e1
--- /dev/null
+++ b/.classpath
@@ -0,0 +1,11 @@
+
+
+
+
+
+
+
+
+
+
+
diff --git a/.project b/.project
new file mode 100644
index 0000000..5e66cd0
--- /dev/null
+++ b/.project
@@ -0,0 +1,17 @@
+
+
+ applicationSupportLayerCore
+
+
+
+
+
+ org.eclipse.jdt.core.javabuilder
+
+
+
+
+
+ org.eclipse.jdt.core.javanature
+
+
diff --git a/.settings/org.eclipse.jdt.ui.prefs b/.settings/org.eclipse.jdt.ui.prefs
new file mode 100644
index 0000000..18848fa
--- /dev/null
+++ b/.settings/org.eclipse.jdt.ui.prefs
@@ -0,0 +1,3 @@
+#Mon Sep 22 12:37:04 EEST 2008
+eclipse.preferences.version=1
+org.eclipse.jdt.ui.text.custom_code_templates=
diff --git a/build.xml b/build.xml
new file mode 100644
index 0000000..e637b31
--- /dev/null
+++ b/build.xml
@@ -0,0 +1,71 @@
+
+
+
+
+
+
+ Compiling project source code
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/etc/ehcache.xml b/etc/ehcache.xml
new file mode 100644
index 0000000..38fbfe7
--- /dev/null
+++ b/etc/ehcache.xml
@@ -0,0 +1,538 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/etc/settings.properties b/etc/settings.properties
new file mode 100644
index 0000000..8ce600a
--- /dev/null
+++ b/etc/settings.properties
@@ -0,0 +1 @@
+sharedDir=${catalina.home}/shared/d4s
\ No newline at end of file
diff --git a/etc/vomsAPI.properties b/etc/vomsAPI.properties
new file mode 100644
index 0000000..0c7bd2f
--- /dev/null
+++ b/etc/vomsAPI.properties
@@ -0,0 +1,18 @@
+MYPROXY_HOST=grids04.eng.it
+MYPROXY_PORT=7512
+PROXIES_DIR=#path to dir where the proxy files will be storeed#
+HOST_CERT=#myproxy certificate#
+HOST_KEY=#myproxy key#
+
+NEW_SERVLET_HOST=dl14.di.uoa.gr #hostname for voms servlet#
+NEW_SERVLET_PORT=8888 #port where voms servlet is listening#
+NEW_SERVLET_PATH=/VOMSServlet/VOMSServlet #voms servlet path#
+NEW_SERVLET_PROTOCOL=http # protocol: http/https#
+
+KEY_STORE=#path to *.p12 key file#
+KEY_STORE_TYPE=PKCS12
+KEY_STORE_PWD=#password for the *.p12 key file#
+
+TRUST_STORE=#path to trust store file#
+TRUST_STORE_PWD=#password for the trust store file#
+TRUST_STORE_TYPE=JKS
\ No newline at end of file
diff --git a/src/org/gcube/application/framework/core/cache/CachesManager.java b/src/org/gcube/application/framework/core/cache/CachesManager.java
new file mode 100644
index 0000000..743d091
--- /dev/null
+++ b/src/org/gcube/application/framework/core/cache/CachesManager.java
@@ -0,0 +1,137 @@
+package org.gcube.application.framework.core.cache;
+
+import java.util.HashMap;
+
+import org.gcube.application.framework.core.cache.factories.GenericResourceCacheEntryFactory;
+
+import net.sf.ehcache.CacheManager;
+import net.sf.ehcache.Ehcache;
+import net.sf.ehcache.constructs.blocking.CacheEntryFactory;
+import net.sf.ehcache.constructs.blocking.SelfPopulatingCache;
+
+/**
+ * @author Valia Tsagkalidou (KNUA)
+ *
+ * This class is a singleton that manages the available caches
+ *
+ */
+public class CachesManager {
+ protected static CachesManager cacheManager = new CachesManager();
+ protected CacheManager manager;
+// protected Ehcache profileCache;
+// protected Ehcache genericResourceCache;
+// protected Ehcache searchConfigCache;
+// protected Ehcache collectionCache;
+// protected Ehcache contentCache;
+// protected Ehcache thumbnailCache;
+// protected Ehcache schemataCache;
+// protected Ehcache metadataCache;
+
+ protected HashMap caches;
+
+ /**
+ * The constructor
+ */
+ protected CachesManager() {
+
+ manager = CacheManager.create(CachesManager.class.getResource("/etc/ehcache.xml"));
+
+ caches = new HashMap();
+
+// profileCache = manager.getEhcache("profiles");
+ Ehcache genericResourceCache = manager.getEhcache("genericResources");
+// searchConfigCache = manager.getEhcache("searchConfiguration");
+// collectionCache = manager.getEhcache("collections");
+// contentCache = manager.getEhcache("content");
+// thumbnailCache = manager.getEhcache("thumbnail");
+// schemataCache = manager.getEhcache("schemata");
+// metadataCache = manager.getEhcache("metadata");
+
+// profileCache = new SelfPopulatingCache(profileCache, new ProfileCacheEntryFactory());
+ genericResourceCache = new SelfPopulatingCache(genericResourceCache, new GenericResourceCacheEntryFactory());
+ caches.put("genericResourceCache", genericResourceCache);
+// searchConfigCache = new SelfPopulatingCache(searchConfigCache, new SearchConfigCacheEntryFactory());
+// collectionCache = new SelfPopulatingCache(collectionCache, new CollectionCacheEntryFactory());
+// contentCache = new SelfPopulatingCache(contentCache, new ContentInfoCacheEntryFactory());
+// thumbnailCache = new SelfPopulatingCache(thumbnailCache, new ThumbnailCacheEntryFactory());
+// schemataCache = new SelfPopulatingCache(schemataCache, new SchemaInfoCacheEntryFactory());
+// metadataCache = new SelfPopulatingCache(metadataCache, new MetadataCacheEntryFactory());
+ }
+
+ /**
+ * @return the sigleton of CachesManager
+ */
+ public static CachesManager getInstance() {
+ return cacheManager;
+ }
+
+ public Ehcache getEhcache (String cacheName, CacheEntryFactory cacheFactory) {
+ if (caches.get(cacheName) == null) {
+ Ehcache newCache = manager.getEhcache(cacheName);
+ newCache = new SelfPopulatingCache(newCache, cacheFactory);
+ caches.put(cacheName, newCache);
+ }
+
+ return caches.get(cacheName);
+ }
+
+
+
+
+ /**
+ * @return the cache that contains the user profiles
+ */
+// public Ehcache getProfileCache() {
+// return profileCache;
+// }
+
+ /**
+ * @return the cache that contains the generic resources
+ */
+ public Ehcache getGenericResourceCache() {
+ return caches.get("genericResourceCache");
+ }
+
+ /**
+ * @return the cache that contains the search configurations
+ */
+// public Ehcache getSearchConfigCache() {
+// return searchConfigCache;
+// }
+
+ /**
+ * @return the cache that contains the collections per VRE
+ */
+// public Ehcache getCollectionCache() {
+// return collectionCache;
+// }
+
+ /**
+ * @return the cache that contains information about digital objects
+ */
+// public Ehcache getContentCache() {
+// return contentCache;
+// }
+
+ /**
+ * @return the cache that contains thumbnails
+ */
+// public Ehcache getThumbnailCache() {
+// return thumbnailCache;
+// }
+
+ /**
+ * @return the cache that contains the searchable fields for each metadata schema
+ */
+// public Ehcache getSchemataCache() {
+// return schemataCache;
+// }
+
+ /**
+ * @return the cache that contains the metadata objects
+ */
+// public Ehcache getMetadataCache() {
+// return metadataCache;
+// }
+
+}
diff --git a/src/org/gcube/application/framework/core/cache/RIsManager.java b/src/org/gcube/application/framework/core/cache/RIsManager.java
new file mode 100644
index 0000000..a6247eb
--- /dev/null
+++ b/src/org/gcube/application/framework/core/cache/RIsManager.java
@@ -0,0 +1,77 @@
+package org.gcube.application.framework.core.cache;
+
+import java.util.HashMap;
+
+import org.gcube.common.core.scope.GCUBEScope;
+import org.gcube.common.core.utils.logging.GCUBELog;
+import org.gcube.informationsystem.cache.ISCache;
+import org.gcube.informationsystem.cache.ISCacheManager;
+
+
+/**
+ * This class manages the running harvester threads.
+ *
+ * @author Valia Tsagkalidou (KNUA)
+ *
+ */
+
+public class RIsManager {
+
+
+ /**
+ * Defines the manager's instance
+ */
+ private static RIsManager instance = null;
+
+ /**
+ * keeps the ISCache per scope
+ */
+ protected HashMap isCaches;
+
+ /** Object logger. */
+ protected final GCUBELog logger = new GCUBELog(this);
+
+ /**
+ * Initializes RIsManager
+ */
+ private RIsManager() {
+ isCaches = new HashMap();
+ }
+
+ /**
+ * Retrieves the singleton
+ * @return the only instance of RIsManager
+ */
+ synchronized public static RIsManager getInstance() {
+ if (instance == null)
+ instance = new RIsManager();
+ return instance;
+ }
+
+ /**
+ * @param scope the GGUBEScope for which the RIs are requested
+ * @return the ISCache for this specific scope
+ */
+ public synchronized ISCache getISCache(GCUBEScope scope)
+ {
+ ISCache isInfo = isCaches.get(scope);
+ if(isInfo == null)
+ {
+ // If the ISCache in not already created, then it creates a new instance and adds it to the HashMap
+ try {
+ ISCacheManager.addManager(scope);
+ isInfo = ISCacheManager.getManager(scope).getCache();
+ isCaches.put(scope, isInfo);
+ try {
+ Thread.sleep(5000);
+ } catch (InterruptedException e1) {
+ logger.error("", e1);
+ }
+ } catch (Exception e) {
+ logger.error("", e);
+ }
+ }
+ return isInfo;
+ }
+
+}
diff --git a/src/org/gcube/application/framework/core/cache/factories/ApplicationCredentials.java b/src/org/gcube/application/framework/core/cache/factories/ApplicationCredentials.java
new file mode 100644
index 0000000..7d51e84
--- /dev/null
+++ b/src/org/gcube/application/framework/core/cache/factories/ApplicationCredentials.java
@@ -0,0 +1,96 @@
+package org.gcube.application.framework.core.cache.factories;
+
+import java.util.HashMap;
+
+import org.gcube.application.framework.core.security.PortalSecurityManager;
+import org.gcube.application.framework.core.security.VOMSAdminManager;
+import org.gcube.application.framework.core.util.UserCredential;
+import org.gcube.common.core.scope.GCUBEScope;
+import org.gcube.common.core.security.utils.VOMSAttributesReader;
+import org.gcube.common.core.utils.logging.GCUBELog;
+import org.gcube.vomanagement.vomsAdmin.impl.VOMSAdminImpl;
+import org.gridforum.jgss.ExtendedGSSCredential;
+
+/**
+ * This class is used for retrieving and updating the portal credential that is needed by the caches in order to retrieve information form gCube services
+ * @author Valia Tsagkalidou (NKUA)
+ *
+ */
+public class ApplicationCredentials {
+ private static ApplicationCredentials applCredentials = new ApplicationCredentials();
+ private HashMap creds;
+ protected static String userDN = "/O=Grid/OU=GlobusTest/OU=simpleCA-gauss.eng.it/OU=eng.it/CN=";
+ protected static String userCA = "/O=Grid/OU=GlobusTest/OU=simpleCA-gauss.eng.it/CN=Globus Simple CA";
+
+
+ /** Object logger. */
+ protected final GCUBELog logger = new GCUBELog(this);
+
+ /**
+ * The basic constructor
+ */
+ protected ApplicationCredentials()
+ {
+ creds = new HashMap();
+ }
+
+ /**
+ * @return the sigleton of ApplicationCredentials
+ */
+ public static ApplicationCredentials getInstance()
+ {
+ return applCredentials;
+ }
+
+ /**
+ * @param VREname the of the VRE for which you want to get the "portal" credential
+ * @return the grid credential
+ */
+ public ExtendedGSSCredential getCredential(String VREname)
+ {
+ PortalSecurityManager secMan = new PortalSecurityManager(GCUBEScope.getScope(VREname));
+ if(!secMan.isSecurityEnabled())
+ return null;
+ ExtendedGSSCredential cred = creds.get(VREname);
+ if(cred == null)
+ {
+ // If the creedential is not available, it retrieves it from myProxy
+ cred = UserCredential.getCredential("application", VREname);
+ if(cred == null)
+ {
+ //user "application" does not exist on this VRE, so we add him and try to get credential again
+ VOMSAdminImpl vomsA;
+ try {
+ vomsA = VOMSAdminManager.getVOMSAdmin();
+ String[] roles = vomsA.listRoles();
+ vomsA.createUser("application", userDN+"application", userCA, "application@gcube.org");
+ vomsA.addMember(VREname, userDN+"application", userCA);
+ vomsA.assignRole(VREname, roles[0], userDN+"application", userCA);
+ }
+ catch (Exception e) {
+ vomsA = null;
+ logger.error("", e);
+ }
+ cred = UserCredential.getCredential("application", VREname);
+ }
+ creds.put(VREname, cred);
+ }
+ else
+ {
+ // credential already available
+ VOMSAttributesReader vomsReader = null;
+ try {
+ vomsReader = new VOMSAttributesReader(cred);
+ //Check if it's gonna expire in the next minute, and refresh it
+ if(vomsReader.getRefreshPeriod() < 60000)
+ {
+ cred = UserCredential.getCredential("application", VREname);
+ creds.put(VREname, cred);
+ }
+ } catch (Exception e1) {
+ logger.error("", e1);
+ }
+ }
+ return cred;
+ }
+}
diff --git a/src/org/gcube/application/framework/core/cache/factories/GenericResourceCacheEntryFactory.java b/src/org/gcube/application/framework/core/cache/factories/GenericResourceCacheEntryFactory.java
new file mode 100644
index 0000000..0ebd92b
--- /dev/null
+++ b/src/org/gcube/application/framework/core/cache/factories/GenericResourceCacheEntryFactory.java
@@ -0,0 +1,117 @@
+
+package org.gcube.application.framework.core.cache.factories;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.gcube.application.framework.core.genericresources.model.ISGenericResource;
+import org.gcube.application.framework.core.util.CacheEntryConstants;
+import org.gcube.application.framework.core.util.QueryString;
+import org.gcube.application.framework.core.util.SessionConstants;
+import org.gcube.common.core.contexts.GCUBEContext;
+import org.gcube.common.core.contexts.GHNContext;
+import org.gcube.common.core.informationsystem.client.AtomicCondition;
+import org.gcube.common.core.informationsystem.client.ISClient;
+import org.gcube.common.core.informationsystem.client.queries.GCUBEGenericResourceQuery;
+import org.gcube.common.core.resources.GCUBEGenericResource;
+import org.gcube.common.core.scope.GCUBEScope;
+import org.gcube.common.core.utils.logging.GCUBELog;
+
+import net.sf.ehcache.constructs.blocking.CacheEntryFactory;
+
+/**
+ * @author Valia Tsagkalidou
+ *
+ */
+public class GenericResourceCacheEntryFactory implements CacheEntryFactory {
+
+ static ISClient client = null;
+
+
+ /** Object logger. */
+ protected final GCUBELog logger = new GCUBELog(this);
+
+ /**
+ * Constructor to initialize the ISClient
+ */
+ public GenericResourceCacheEntryFactory() {
+ super();
+ if(client == null)
+ {
+ try {
+ client = GHNContext.getImplementation(ISClient.class);
+ } catch (Exception e) {
+ logger.error("",e);
+ }
+ }
+ }
+
+
+
+
+ /**
+ * @param key a QueryString representing pairs of keys and values: needed keys are "vre" and one of "id" or "name"
+ * @return a list containing the Generic Resources that correspond to the query
+ */
+ public List createEntry(Object key) throws Exception {
+ QueryString querySt = (QueryString) key;
+ logger.info("query: " + querySt.toString());
+ GCUBEScope scope = GCUBEScope.getScope(querySt.get(CacheEntryConstants.vre));
+ GCUBEGenericResourceQuery query = client.getQuery(GCUBEGenericResourceQuery.class);
+
+ logger.info("In generic resources cache entry factory");
+
+ if(querySt.containsKey(CacheEntryConstants.id))
+ { //Retrieving generic resources based on their ID
+ query.addAtomicConditions(new AtomicCondition("/ID", querySt.get(CacheEntryConstants.id)));
+
+ }
+ // else if(querySt.containsKey(CacheEntryConstants.name) && querySt.get(CacheEntryConstants.name).equals(SessionConstants.ScenarioSchemaInfo))
+ // { //Retrieving the generic resource that represents the static search configuration
+ // query.addAtomicConditions(new AtomicCondition("/Profile/Name", querySt.get(CacheEntryConstants.name)));
+ // query.addAtomicConditions(new AtomicCondition("/Profile/Body/DL/attribute::name", querySt.get(CacheEntryConstants.vre)));
+ // }
+ else if(querySt.containsKey(CacheEntryConstants.name))
+ { //Retrieving generic resources based on their name
+ query.addAtomicConditions(new AtomicCondition("/Profile/Name", querySt.get(CacheEntryConstants.name)));
+ }
+ else if(querySt.containsKey(CacheEntryConstants.vreResource))
+ {
+
+ query.addAtomicConditions(new AtomicCondition("//SecondaryType", GCUBEGenericResource.SECONDARYTYPE_VRE), new AtomicCondition("//Body/Scope", scope.toString()));
+
+ }
+
+ try{
+ List result = client.execute(query, scope);
+ List res = new ArrayList();
+ if (querySt.containsKey(CacheEntryConstants.name) && querySt.get(CacheEntryConstants.name).equals(SessionConstants.ScenarioSchemaInfo)) {
+ System.out.println("The number of generic Resources for ScenarioSchemaInfo returned is: " + result.size());
+ List newResult = new ArrayList();
+ for (GCUBEGenericResource resource : result) {
+ Map scopes = resource.getScopes();
+ System.out.println("Number of scopes for ScenarioSchemaInfo: " + scopes.values().size());
+ System.out.println(scopes.values().toString());
+ if (scopes.containsValue(scope)) {
+ newResult.add(resource);
+ }
+ }
+ System.out.println("Number of genericResources for ScenarioSchemaInfo left after the pruning" + newResult.size());
+ result = newResult;
+ }
+ logger.debug("size of results: " + result.size());
+ for(GCUBEGenericResource resource : result)
+ {
+ ISGenericResource genResource = new ISGenericResource(resource.getID(), resource.getName(), resource.getDescription(), resource.getBody(), resource.getSecondaryType());
+ res.add(genResource);
+ }
+ return res;
+ }catch (Exception e) {
+ logger.error("",e);
+ return null;
+ }
+ }
+
+}
diff --git a/src/org/gcube/application/framework/core/genericresources/model/ISGenericResource.java b/src/org/gcube/application/framework/core/genericresources/model/ISGenericResource.java
new file mode 100644
index 0000000..2f0df7c
--- /dev/null
+++ b/src/org/gcube/application/framework/core/genericresources/model/ISGenericResource.java
@@ -0,0 +1,114 @@
+package org.gcube.application.framework.core.genericresources.model;
+
+
+/**
+ * @author Valia Tsaqgkalidou (NKUA)
+ *
+ */
+public class ISGenericResource {
+
+ protected String id;
+ protected String name;
+ protected String description;
+ protected String body;
+ protected String secondaryType;
+
+
+ /**
+ * @return the secondary type of the generic resource
+ */
+ public String getSecondaryType() {
+ return secondaryType;
+ }
+
+
+ /**
+ * @param secondaryType the secondary type of the generic resource to be set
+ */
+ public void setSecondaryType(String secondaryType) {
+ this.secondaryType = secondaryType;
+ }
+
+
+ /**
+ * Generic Constructor
+ */
+ public ISGenericResource() {
+ super();
+ this.id = "";
+ this.name = "";
+ this.description = "";
+ this.body = "";
+ this.secondaryType = "";
+ }
+
+
+ /**
+ * @param id the generic resource ID
+ * @param name the generic resource name
+ * @param description the generic resource description
+ * @param body the generic resource body
+ * @param sType the generic resource secondary type
+ */
+ public ISGenericResource(String id, String name, String description,
+ String body, String sType) {
+ super();
+ this.id = id;
+ this.name = name;
+ this.description = description;
+ this.body = body;
+ this.secondaryType = sType;
+ }
+
+
+ /**
+ * @return the id
+ */
+ public String getId() {
+ return id;
+ }
+ /**
+ * @param id the id to set
+ */
+ public void setId(String id) {
+ this.id = id;
+ }
+ /**
+ * @return the name
+ */
+ public String getName() {
+ return name;
+ }
+ /**
+ * @param name the name to set
+ */
+ public void setName(String name) {
+ this.name = name;
+ }
+ /**
+ * @return the description
+ */
+ public String getDescription() {
+ return description;
+ }
+ /**
+ * @param description the description to set
+ */
+ public void setDescription(String description) {
+ this.description = description;
+ }
+ /**
+ * @return the body
+ */
+ public String getBody() {
+ return body;
+ }
+ /**
+ * @param body the body to set
+ */
+ public void setBody(String body) {
+ this.body = body;
+ }
+
+
+}
diff --git a/src/org/gcube/application/framework/core/security/JaasCallbackHandler.java b/src/org/gcube/application/framework/core/security/JaasCallbackHandler.java
new file mode 100644
index 0000000..3704f84
--- /dev/null
+++ b/src/org/gcube/application/framework/core/security/JaasCallbackHandler.java
@@ -0,0 +1,43 @@
+package org.gcube.application.framework.core.security;
+
+import java.io.IOException;
+
+import javax.security.auth.callback.Callback;
+import javax.security.auth.callback.CallbackHandler;
+import javax.security.auth.callback.NameCallback;
+import javax.security.auth.callback.PasswordCallback;
+import javax.security.auth.callback.UnsupportedCallbackException;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+public class JaasCallbackHandler implements CallbackHandler{
+
+ protected String username = null;
+ protected String password = null;
+
+ private Log log = LogFactory.getLog(JaasCallbackHandler.class);
+
+ public JaasCallbackHandler(String username, String password) {
+ super();
+ this.username = username;
+ this.password = password;
+ }
+
+ public void handle(Callback callbacks[])
+ throws IOException, UnsupportedCallbackException {
+ for (int i = 0; i < callbacks.length; i++) {
+ if (callbacks[i] instanceof NameCallback) {
+ if (log.isDebugEnabled()) log.debug("responding to NameCallback");
+ ((NameCallback) callbacks[i]).setName(username);
+ } else if (callbacks[i] instanceof PasswordCallback) {
+ if (log.isDebugEnabled()) log.debug("responding to PasswordCallback");
+ ((PasswordCallback) callbacks[i]).setPassword(password != null ? password.toCharArray() : new char[0]);
+ } else {
+ if (log.isDebugEnabled()) log.debug("unsupported callback: " + callbacks[i].getClass());
+ throw new UnsupportedCallbackException(callbacks[i]);
+ }
+ }
+ }
+
+}
diff --git a/src/org/gcube/application/framework/core/security/LDAPAuthenticationModule.java b/src/org/gcube/application/framework/core/security/LDAPAuthenticationModule.java
new file mode 100644
index 0000000..f888bfc
--- /dev/null
+++ b/src/org/gcube/application/framework/core/security/LDAPAuthenticationModule.java
@@ -0,0 +1,72 @@
+package org.gcube.application.framework.core.security;
+
+
+import javax.security.auth.login.AccountExpiredException;
+import javax.security.auth.login.CredentialExpiredException;
+import javax.security.auth.login.FailedLoginException;
+import javax.security.auth.login.LoginContext;
+import javax.security.auth.login.LoginException;
+
+
+
+
+public class LDAPAuthenticationModule {
+
+ public static String LDAP_HOST = "LDAP_HOST";
+ public static String BASE_DN = "BASE_DN";
+
+
+ private String contextName = "Gridsphere";
+ //private String contextName = "AslLoginConf";
+
+ public LDAPAuthenticationModule () {
+ return;
+ }
+
+
+
+ public boolean checkAuthentication(String username, String password) throws Exception {
+
+ System.out.println("beginning authentication for " + username);
+ System.out.println("I am in ASL");
+
+
+ LoginContext loginContext;
+
+ // Create the LoginContext
+ try {
+ loginContext = new LoginContext(contextName, new JaasCallbackHandler(username, password));
+ } catch (SecurityException e) {
+ e.printStackTrace();
+ throw new Exception("key4", e);
+ } catch (LoginException e) {
+ e.printStackTrace();
+ throw new Exception("key4", e);
+ }
+
+ // Attempt login
+ try {
+ loginContext.login();
+ } catch (FailedLoginException e) {
+ // throw new Exception("key4", e);
+ e.printStackTrace();
+ return false;
+ } catch (AccountExpiredException e) {
+ //throw new Exception("key1");
+ e.printStackTrace();
+ return false;
+ } catch (CredentialExpiredException e) {
+ // throw new Exception("key2", e);
+ e.printStackTrace();
+ return false;
+ } catch (Exception e) {
+ // throw new Exception("key3", e);
+ return false;
+ }
+ System.out.println("ASL returning value true");
+ return true;
+
+ }
+
+
+}
diff --git a/src/org/gcube/application/framework/core/security/PortalSecurityManager.java b/src/org/gcube/application/framework/core/security/PortalSecurityManager.java
new file mode 100644
index 0000000..615e192
--- /dev/null
+++ b/src/org/gcube/application/framework/core/security/PortalSecurityManager.java
@@ -0,0 +1,89 @@
+package org.gcube.application.framework.core.security;
+
+import java.io.BufferedReader;
+import java.io.StringReader;
+import java.util.List;
+
+import org.gcube.application.framework.core.cache.CachesManager;
+import org.gcube.application.framework.core.genericresources.model.ISGenericResource;
+import org.gcube.application.framework.core.session.ASLSession;
+import org.gcube.application.framework.core.util.CacheEntryConstants;
+import org.gcube.application.framework.core.util.QueryString;
+import org.gcube.application.framework.core.util.SessionConstants;
+import org.gcube.common.core.scope.GCUBEScope;
+import org.gcube.common.core.security.GCUBESecurityManagerImpl;
+import org.gcube.common.core.utils.logging.GCUBELog;
+import org.kxml2.io.KXmlParser;
+
+/**
+ * @author Valia Tsagkalidou (KNUA)
+ *
+ */
+public class PortalSecurityManager extends GCUBESecurityManagerImpl {
+
+ /** Object logger. */
+ protected final GCUBELog logger = new GCUBELog(this);
+
+ public PortalSecurityManager(GCUBEScope scope) {
+ super();
+ this.scope = scope;
+ }
+
+ public PortalSecurityManager(ASLSession session) {
+ super();
+ this.scope = session.getScope();
+ }
+
+ GCUBEScope scope;
+
+
+ @Override
+ public boolean isSecurityEnabled() {
+ QueryString query = new QueryString();
+ query.put(CacheEntryConstants.vreResource, "true");
+ query.put(CacheEntryConstants.vre, scope.toString());
+ List res = (List)CachesManager.getInstance().getGenericResourceCache().get(query).getValue();
+ if(res == null || res.size() == 0)
+ return false;
+ else
+ {
+ try {
+ return parseBody(res.get(0).getBody());
+ } catch (Exception e) {
+ logger.error("",e);
+ return false;
+ }
+ }
+ }
+
+ /**
+ * Loads from the Body element the resource information
+ * @param body the Body of the generic resource
+ * @throws Exception if the element is not valid or well formed
+ */
+ private boolean parseBody(String body) throws Exception {
+ KXmlParser parser = new KXmlParser();
+ parser.setInput(new BufferedReader(new StringReader(body)));
+ loop: while (true) {
+ try {
+ switch (parser.next()) {
+ case KXmlParser.START_TAG:
+ if (parser.getName().equals("SecurityEnabled"))
+ {
+ boolean res = Boolean.valueOf(parser.nextText()).booleanValue();
+ logger.debug("Found value:" + res);
+ return res;
+ }
+ else parser.nextText();//just skip the text
+ break;
+ case KXmlParser.END_DOCUMENT: break loop;
+ }
+ } catch (Exception e) {
+ logger.error("",e);
+ throw new Exception ("Unable to parse the ScopeResource body");
+ }
+ }
+ return false;
+ }
+
+}
diff --git a/src/org/gcube/application/framework/core/security/ServiceContextManager.java b/src/org/gcube/application/framework/core/security/ServiceContextManager.java
new file mode 100644
index 0000000..f9fee23
--- /dev/null
+++ b/src/org/gcube/application/framework/core/security/ServiceContextManager.java
@@ -0,0 +1,37 @@
+package org.gcube.application.framework.core.security;
+
+import java.rmi.Remote;
+
+import org.gcube.application.framework.core.session.ASLSession;
+import org.gcube.common.core.contexts.GCUBERemotePortTypeContext;
+import org.gcube.common.core.scope.GCUBEScope;
+import org.gcube.common.core.scope.GCUBEScope.MalformedScopeExpressionException;
+import org.gcube.common.core.security.GCUBESecurityManager;
+import org.ietf.jgss.GSSCredential;
+
+public class ServiceContextManager {
+
+ public static PORTTYPE applySecurity(PORTTYPE stub, ASLSession session) throws MalformedScopeExpressionException, Exception
+ {
+ GCUBESecurityManager secManager = new PortalSecurityManager(session);
+ if(secManager.isSecurityEnabled())
+ {
+ secManager.useCredentials(session.getCredential());
+ }
+ return GCUBERemotePortTypeContext.getProxy(stub , session.getScope(), secManager);
+
+ }
+
+
+ public static PORTTYPE applySecurity(PORTTYPE stub, GCUBEScope scope, GSSCredential cred) throws MalformedScopeExpressionException, Exception
+ {
+ GCUBESecurityManager secManager = new PortalSecurityManager(scope);
+ if(secManager.isSecurityEnabled())
+ {
+ secManager.useCredentials(cred);
+ }
+ return GCUBERemotePortTypeContext.getProxy(stub , scope, secManager);
+
+ }
+
+}
diff --git a/src/org/gcube/application/framework/core/security/VOMSAdminManager.java b/src/org/gcube/application/framework/core/security/VOMSAdminManager.java
new file mode 100644
index 0000000..6895425
--- /dev/null
+++ b/src/org/gcube/application/framework/core/security/VOMSAdminManager.java
@@ -0,0 +1,35 @@
+package org.gcube.application.framework.core.security;
+
+import java.io.File;
+
+import org.gcube.application.framework.core.util.Settings;
+import org.gcube.vomanagement.vomsAdmin.impl.VOMSAdminImpl;
+
+/**
+ * @author Valia Tsagkalidou (NKUA)
+ *
+ */
+public class VOMSAdminManager {
+
+ /**
+ *
+ */
+ protected static VOMSAdminImpl vomsAdmin= null;
+
+ /**
+ * @return
+ */
+ public static VOMSAdminImpl getVOMSAdmin()
+ {
+ if(vomsAdmin == null)
+ {
+ try {
+ vomsAdmin = new VOMSAdminImpl(Settings.getInstance().getProperty("sharedDir")+ File.separator + "vomsAPI.properties");
+ } catch (Exception e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+ return vomsAdmin;
+ }
+}
diff --git a/src/org/gcube/application/framework/core/session/ASLSession.java b/src/org/gcube/application/framework/core/session/ASLSession.java
new file mode 100644
index 0000000..536447d
--- /dev/null
+++ b/src/org/gcube/application/framework/core/session/ASLSession.java
@@ -0,0 +1,222 @@
+package org.gcube.application.framework.core.session;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Set;
+
+import org.gcube.application.framework.core.cache.CachesManager;
+import org.gcube.application.framework.core.security.PortalSecurityManager;
+import org.gcube.application.framework.core.util.SessionConstants;
+import org.gcube.application.framework.core.util.UserCredential;
+import org.gcube.common.core.scope.GCUBEScope;
+import org.gridforum.jgss.ExtendedGSSCredential;
+
+/**
+ * @author Valia Tsagkalidou (NKUA)
+ *
+ */
+public class ASLSession{
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+ private HashMap innerSession;
+ private long lastUsedTime;
+ private String externalSessionID;
+ private String username;
+ private ExtendedGSSCredential credential;
+ private GCUBEScope scope;
+ private HashMap notifiers;
+
+ /**
+ * A constructor based on the user and an external ID
+ * @param externalSessionId the external id
+ * @param user the username
+ */
+ ASLSession(String externalSessionId, String user)
+ {
+ innerSession = new HashMap();
+ notifiers = new HashMap();
+ lastUsedTime = System.currentTimeMillis();
+ username = user;
+ externalSessionID = externalSessionId;
+ }
+
+ private void initializeAttributes() {
+ }
+
+ /**
+ * @return whether the session is still valid or not
+ */
+ public boolean isValid()
+ {
+ if((System.currentTimeMillis() - lastUsedTime) > 1800000) // 30 minutes
+ return false;
+ return true;
+ }
+
+ /**
+ * @return whether the session is empty or not
+ */
+ public boolean isEmpty()
+ {
+ lastUsedTime = System.currentTimeMillis();
+ return innerSession.isEmpty();
+ }
+
+ /**
+ * @param name the name of the attribute
+ * @return whether the name attribute exists in the session
+ */
+ public boolean hasAttribute(String name)
+ {
+ lastUsedTime = System.currentTimeMillis();
+ return innerSession.containsKey(name);
+ }
+
+ /**
+ * @return a set of all the attributes in the session
+ */
+ public Set getAttributeNames()
+ {
+ lastUsedTime = System.currentTimeMillis();
+ return innerSession.keySet();
+ }
+
+ /**
+ * @param name the name of the attribute
+ * @return the value of the named attribute
+ */
+ public Object getAttribute(String name)
+ {
+ lastUsedTime = System.currentTimeMillis();
+ return innerSession.get(name);
+ }
+
+ /**
+ * @param name the name of the attribute
+ * @param value the value of the attribute
+ */
+ public void setAttribute(String name, Object value)
+ {
+ lastUsedTime = System.currentTimeMillis();
+ innerSession.put(name, value);
+ }
+
+ /**
+ * Removes the named attribute from the session
+ * @param name the name of the attribute
+ * @return the removed object
+ */
+ public Object removeAttribute(String name)
+ {
+ lastUsedTime = System.currentTimeMillis();
+ return innerSession.remove(name);
+ }
+
+ /**
+ * Removes all the attributes from the session
+ */
+ public void removeAll()
+ {
+ lastUsedTime = System.currentTimeMillis();
+ innerSession.clear();
+ }
+
+ /**
+ * invalidates the session
+ */
+ public void invalidate()
+ {
+ lastUsedTime = System.currentTimeMillis() - 2000000; //more than 30 minutes
+ }
+
+ /**
+ * @return the credential
+ */
+ public ExtendedGSSCredential getCredential() {
+ return credential;
+ }
+
+ /**
+ * @return the external session id (passed to the constructor)
+ */
+ public String getExternalSessionID() {
+ return externalSessionID;
+ }
+
+ /**
+ * @return the username
+ */
+ public String getUsername() {
+ return username;
+ }
+
+ /**
+ * @return the scope
+ */
+ public GCUBEScope getScope() {
+ return scope;
+ }
+
+ /**
+ * @return the name of the scope (VRE)
+ */
+ public String getScopeName()
+ {
+ return scope.toString();
+ }
+
+ /**
+ * @param scope the scope name (VRE)
+ */
+ public void setScope(String scope) {
+ lastUsedTime = System.currentTimeMillis();
+ String[] split = scope.trim().substring(1).split("/",2);
+ String vo = "/" + split[0].toLowerCase();
+ if(split.length > 1)
+ vo += "/" + split[1];
+ System.out.println("*** VRE to be set:" + vo + " ***");
+ this.scope = GCUBEScope.getScope(vo);
+ if(new PortalSecurityManager(this.scope).isSecurityEnabled())
+ this.credential = UserCredential.getCredential(username, scope);
+ innerSession.clear();
+ initializeAttributes();
+ }
+
+ /**
+ * @param notification the name of the notification to wait for
+ * @throws InterruptedException when the thread is interrupted
+ */
+ public void waitNotification(String notification) throws InterruptedException
+ {
+ Notifier notifier = notifiers.get(notification);
+ if(notifier == null)
+ {
+ notifier = new Notifier();
+ notifiers.put(notification, notifier);
+ }
+
+ lastUsedTime = System.currentTimeMillis();
+ notifier.waitNotification();
+ }
+
+ /**
+ * @param notification the name of the notification to send notification
+ * @throws InterruptedException when the thread is interrupted
+ */
+ public void notifyAllWaiting(String notification) throws InterruptedException
+ {
+ Notifier notifier = notifiers.get(notification);
+ if(notifier == null)
+ {
+ notifier = new Notifier();
+ notifiers.put(notification, notifier);
+ }
+
+ lastUsedTime = System.currentTimeMillis();
+ notifier.notifyAllWaiting();
+ }
+}
diff --git a/src/org/gcube/application/framework/core/session/Notifier.java b/src/org/gcube/application/framework/core/session/Notifier.java
new file mode 100644
index 0000000..904f269
--- /dev/null
+++ b/src/org/gcube/application/framework/core/session/Notifier.java
@@ -0,0 +1,25 @@
+package org.gcube.application.framework.core.session;
+
+import java.util.concurrent.Semaphore;
+
+class Notifier {
+
+ Semaphore sem;
+
+ Notifier() {
+ sem = new Semaphore(0, true);
+ }
+
+
+ public void waitNotification() throws InterruptedException
+ {
+ sem.acquire();
+ System.out.println("\n\njust woke up!!!\n\n");
+ }
+
+ public void notifyAllWaiting() throws InterruptedException
+ {
+ System.out.println("Sending wake up signal to " + sem.getQueueLength() + " receivers...");
+ sem.release(sem.getQueueLength());
+ }
+}
diff --git a/src/org/gcube/application/framework/core/session/SessionManager.java b/src/org/gcube/application/framework/core/session/SessionManager.java
new file mode 100644
index 0000000..ab4ad2c
--- /dev/null
+++ b/src/org/gcube/application/framework/core/session/SessionManager.java
@@ -0,0 +1,75 @@
+package org.gcube.application.framework.core.session;
+
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Set;
+
+
+public class SessionManager {
+
+ protected static Thread thread = new CleanSessionThread();
+ protected static SessionManager sessionManager = new SessionManager();
+ protected HashMap sessions;
+
+ protected SessionManager() {
+ sessions = new HashMap();
+ thread.setDaemon(true);
+ thread.start();
+ }
+
+ public static SessionManager getInstance() {
+ return sessionManager;
+ }
+
+ public ASLSession getD4ScienceSession(String externalSessionID, String username)
+ {
+ ASLSession session = sessions.get(externalSessionID + "_" + username);
+ if(session == null || !session.isValid() || !session.getUsername().equals(username))
+ {
+ session = new ASLSession(externalSessionID, username);
+ sessions.put(externalSessionID + "_" + username, session);
+ }
+ return session;
+ }
+
+ @Override
+ protected void finalize() throws Throwable {
+ thread.interrupt();
+ System.out.println(new Date(System.currentTimeMillis()) + " clean thread was interrupted");
+ thread.join();
+ System.out.println(new Date(System.currentTimeMillis()) + " clean thread was joint");
+ super.finalize();
+ }
+
+
+ protected static class CleanSessionThread extends Thread
+ {
+ public void run()
+ {
+ while(true)
+ {
+ try {
+ Thread.sleep(600000);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ System.out.println(new Date(System.currentTimeMillis()) + " clean thread was interrupted (in clean thread)");
+ break;
+ }
+ //TODO: cleanup invalid sessions: add locks...
+ Set keys = sessionManager.sessions.keySet();
+ Iterator iter = keys.iterator();
+ while(iter.hasNext())
+ {
+ String extSessionID = iter.next();
+ if(!sessionManager.sessions.get(extSessionID).isValid())
+ {
+ sessionManager.sessions.remove(extSessionID);
+ }
+ }
+ }
+ System.out.println(new Date(System.currentTimeMillis()) + " clean thread was terminated");
+ }
+
+ }
+}
diff --git a/src/org/gcube/application/framework/core/util/CacheEntryConstants.java b/src/org/gcube/application/framework/core/util/CacheEntryConstants.java
new file mode 100644
index 0000000..d3d7f38
--- /dev/null
+++ b/src/org/gcube/application/framework/core/util/CacheEntryConstants.java
@@ -0,0 +1,59 @@
+package org.gcube.application.framework.core.util;
+
+/**
+ * @author Valia Tsagkalidou (KNUA)
+ *
+ */
+public class CacheEntryConstants {
+
+ /**
+ * Cache constant for VRE
+ */
+ public static final String vre = "vre";
+
+ /**
+ * Cache constant for oid
+ */
+ public static final String oid = "oid";
+
+ /**
+ * Cache constant for metadataColID
+ */
+ public static final String metadataColID = "metadataColID";
+
+ /**
+ * Cache constant for name
+ */
+ public static final String name = "name";
+
+ /**
+ * Cache constant for id
+ */
+ public static final String id = "id";
+
+ /**
+ * Cache constant for username
+ */
+ public static final String username = "username";
+
+ /**
+ * Cache constant for width
+ */
+ public static final String width = "width";
+
+ /**
+ * Cache constant for height
+ */
+ public static final String height = "height";
+
+ /**
+ * thumbOptions
+ */
+ public static final String thumbOptions = "thumbOptions";
+
+ /**
+ * vreResource
+ */
+ public static final String vreResource = "vreResource";
+
+}
diff --git a/src/org/gcube/application/framework/core/util/NotificationConstants.java b/src/org/gcube/application/framework/core/util/NotificationConstants.java
new file mode 100644
index 0000000..77e9f72
--- /dev/null
+++ b/src/org/gcube/application/framework/core/util/NotificationConstants.java
@@ -0,0 +1,11 @@
+package org.gcube.application.framework.core.util;
+
+/**
+ * @author Valia Tsagkalidou (KNUA)
+ *
+ */
+public class NotificationConstants {
+
+ public static final String CollectionsStatusChange = "CollectionsStatusChange";
+
+}
diff --git a/src/org/gcube/application/framework/core/util/QueryString.java b/src/org/gcube/application/framework/core/util/QueryString.java
new file mode 100644
index 0000000..ddad06b
--- /dev/null
+++ b/src/org/gcube/application/framework/core/util/QueryString.java
@@ -0,0 +1,30 @@
+package org.gcube.application.framework.core.util;
+
+import java.util.HashMap;
+
+/**
+ * @author Valia Tsagkalidou (KNUA)
+ *
+ */
+public class QueryString extends HashMap{
+
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ public QueryString() {
+ super();
+ }
+
+ public void addParameter(String name, String value)
+ {
+ this.put(name, value);
+ }
+
+ public void removeParameter(String name)
+ {
+ this.remove(name);
+ }
+
+}
diff --git a/src/org/gcube/application/framework/core/util/SearchField.java b/src/org/gcube/application/framework/core/util/SearchField.java
new file mode 100644
index 0000000..50619b5
--- /dev/null
+++ b/src/org/gcube/application/framework/core/util/SearchField.java
@@ -0,0 +1,54 @@
+package org.gcube.application.framework.core.util;
+
+import java.io.Serializable;
+
+/**
+ *
+ * @author Panagiota Koltsida (NKUA)
+ * @author Valia Tsagkalidou (NKUA)
+ *
+ */
+//TODO: Done!!!
+public class SearchField implements Serializable, Cloneable{
+ /**
+ *
+ */
+ private static final long serialVersionUID = 1L;
+
+ /**
+ * Name of the criterion
+ */
+ public String name;
+
+ /**
+ * Value of the criterion
+ */
+ public String value;
+
+ /**
+ * Type of the criterion
+ */
+ public String type;
+
+ /**
+ * The x-path to apply for sorting the results
+ */
+ public String sort;
+
+ public SearchField() {
+ name = "";
+ value = "";
+ type = "";
+ sort = "";
+ }
+
+ /* (non-Javadoc)
+ * @see java.lang.Object#clone()
+ */
+ @Override
+ public SearchField clone() throws CloneNotSupportedException {
+ // TODO Auto-generated method stub
+ return (SearchField) super.clone();
+ }
+
+}
diff --git a/src/org/gcube/application/framework/core/util/SessionConstants.java b/src/org/gcube/application/framework/core/util/SessionConstants.java
new file mode 100644
index 0000000..8dd6b12
--- /dev/null
+++ b/src/org/gcube/application/framework/core/util/SessionConstants.java
@@ -0,0 +1,119 @@
+package org.gcube.application.framework.core.util;
+
+/**
+ * @author Valia Tsagkalidou (KNUA)
+ *
+ */
+public class SessionConstants {
+
+ /**
+ * Used for generic resource name which contains the static search configuration
+ */
+ public static final String ScenarioSchemaInfo = "ScenarioCollectionInfo";
+
+ /**
+ * Used for a variable in the session representing a HashMap>:
+ * pairs: (schema, list of searchable fields for this schema)
+ */
+ public static final String SchemataInfo = "SchemataInfo";
+
+ /**
+ * Used for generic resource name which contains info about searchable fields per schema...
+ */
+ public static final String MetadataSchemaInfo = "MetadataSchemaInfo";
+
+ /**
+ * Used for a variable in the session representing the available collections
+ */
+ public static final String Collections = "Collections";
+
+ /**
+ * Used for a variable in the session representing the available queries (queries that the user has created)
+ */
+ public static final String Queries = "Queries";
+
+ /**
+ * Used for a variable in the session that contains info for the geospatial search (boundinf box, time interval, etc)
+ */
+ public static final String Geospatial = "Geospatial";
+
+ /**
+ * Used for a variable in the session representing the number of the current page number in the results.
+ */
+ public static final String page_no = "page_no";
+
+ /**
+ * Used for a variable in the session representing how many results were actually read from resultset last time
+ */
+ public static final String resNo = "resNo";
+
+ /**
+ * Used for a variable in the session representing the total number of result pages...
+ */
+ public static final String page_total = "page_total";
+
+ /**
+ * Used for a variable in the session representing the index in the current resultset part (where we stopped reading results last time)
+ */
+ public static final String lastRes = "lastRes";
+
+ /**
+ * Used for a variable in the session representing whether we have reach the last page of results
+ */
+ public static final String isLast = "isLast";
+
+ /**
+ * Used for a variable in the session that contains info about whether we have go beyond the edges of results... (out of index)
+ */
+ public static final String out_of_end = "out_of_end";
+
+ /**
+ * the current resultset client
+ */
+ public static final String rsClient = "rsClient";
+
+ /**
+ * the results objects already processed from the resultset
+ */
+ public static final String theResultObjects = "theResultObjects";
+
+ /**
+ * the thumbnail urls for each result object (already processed from the resultset )
+ */
+ public static final String theThumbnails = "theThumbnails";
+
+ /**
+ * the index in the result objects from where we should start reading
+ */
+ public static final String startingPoint = "startingPoint";
+
+ /**
+ * what type search was applied (Simple, Advanced, Browse, Quick, Google, etc)
+ */
+ public static final String sourcePortlet = "sourcePortlet";
+
+ /**
+ * the resultset EPR (not used any more)
+ */
+ public static final String rsEPR = "rsEPR"; /* the Result Set EPR */
+
+ /**
+ * whether to show result rank or not
+ */
+ public static final String showRank = "showRank";
+
+ /**
+ * an exception occured during search: message to the users
+ */
+ public static final String searchException = "searchException";
+
+ /**
+ * the id of the active query
+ */
+ public static final String activeQueryNo = "activeQueryNo";
+
+ /**
+ * the id of the active query to be presented
+ */
+ public static final String activePresentationQueryNo = "activePresentationQueryNo";
+}
diff --git a/src/org/gcube/application/framework/core/util/Settings.java b/src/org/gcube/application/framework/core/util/Settings.java
new file mode 100644
index 0000000..cc42fcc
--- /dev/null
+++ b/src/org/gcube/application/framework/core/util/Settings.java
@@ -0,0 +1,58 @@
+package org.gcube.application.framework.core.util;
+
+import java.io.*;
+import java.util.*;
+import java.net.URISyntaxException;
+
+public class Settings {
+
+ static Properties props = new Properties();
+ static Settings settings = null;
+
+ Settings()
+ {
+ try
+ {
+ props.load(Settings.class.getResourceAsStream("/etc/settings.properties"));
+
+ }
+ catch (FileNotFoundException e)
+ {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ catch (IOException e)
+ {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ }
+
+ public static Settings getInstance()
+ {
+ if (settings == null)
+ settings = new Settings();
+ return settings;
+ }
+
+ /**
+ * @return the props
+ */
+ public String getProperty(String key) {
+ String value = props.getProperty(key);
+ if(value.contains("${"))
+ {
+ int start = 0;
+ int i;
+ while((i= value.indexOf("${", start)) != -1)
+ {
+ start = value.indexOf("}", i) +1;
+ String reg = value.substring(i, start);
+ System.out.println(reg);
+ System.out.println(reg.substring(2, reg.length() -1));
+ value = value.replace(reg, (System.getProperty(reg.substring(2, reg.length() -1)) != null)?System.getProperty(reg.substring(2, reg.length() -1)):"");
+ }
+ }
+ return value;
+ }
+}
diff --git a/src/org/gcube/application/framework/core/util/TransformXSLT.java b/src/org/gcube/application/framework/core/util/TransformXSLT.java
new file mode 100644
index 0000000..41b19f4
--- /dev/null
+++ b/src/org/gcube/application/framework/core/util/TransformXSLT.java
@@ -0,0 +1,120 @@
+package org.gcube.application.framework.core.util;
+
+import java.io.BufferedReader;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.io.StringWriter;
+
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.stream.StreamResult;
+import javax.xml.transform.stream.StreamSource;
+
+import org.apache.xml.serialize.OutputFormat;
+import org.apache.xml.serialize.XMLSerializer;
+import org.w3c.dom.Document;
+
+/**
+ * @author Valia Tsagkalidou (KNUA)
+ *
+ */
+public class TransformXSLT {
+ /**
+ * Transforms an xml document based on the given xslt
+ * @param xslt the xslt for transforming the xml
+ * @param xml the xml to be transformed
+ * @return a string containing the transformed xml (output of the transformation)
+ */
+ public static String transform(String xslt, String xml)
+ {
+ Transformer transformer;
+ try
+ {//Retrieve the XSLT from the DIS (generic resource), and create the transformer
+ ByteArrayInputStream xsltStream = new ByteArrayInputStream(xslt.getBytes());
+ TransformerFactory tFactory = TransformerFactory.newInstance();
+ transformer = tFactory.newTransformer(new StreamSource(xsltStream));
+
+ DocumentBuilderFactory dfactory = DocumentBuilderFactory.newInstance();
+ Document doc = null;
+
+ doc = dfactory.newDocumentBuilder().parse(xml);
+ // Apply the transformation
+ ByteArrayOutputStream ba_stream = new ByteArrayOutputStream();
+ OutputFormat format = new OutputFormat(doc);
+ format.setIndenting(false);
+ format.setOmitDocumentType(true);
+ format.setOmitXMLDeclaration(true);
+ StringWriter writer = new StringWriter();
+ XMLSerializer serial = new XMLSerializer(writer,format);
+ serial.serialize(doc);
+ transformer.transform(new StreamSource(new ByteArrayInputStream(writer.toString().getBytes())), new StreamResult(ba_stream));
+ //Prepares the object to be returned
+ StringBuffer buffer = new StringBuffer();
+ try {
+ InputStreamReader isr = new InputStreamReader( new ByteArrayInputStream(ba_stream.toByteArray()),
+ "UTF8");
+ Reader in2 = new BufferedReader(isr);
+ int ch;
+ while ((ch = in2.read()) > -1) {
+ buffer.append((char)ch);
+ }
+ in2.close();
+ return buffer.toString();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ catch (Exception e) {
+ e.printStackTrace();
+ }
+ return null;
+ }
+
+ /**
+ * Transforms an xml document based on the given transformer
+ * @param transformer the transformer based on which the transformation will be applied
+ * @param xml the xml document to be transformed
+ * @return a string containing the transformed xml (output of the transformation)
+ */
+ public static String transform(Transformer transformer, String xml)
+ {
+ DocumentBuilderFactory dfactory = DocumentBuilderFactory.newInstance();
+ Document doc = null;
+
+ try
+ {
+ doc = dfactory.newDocumentBuilder().parse(xml);
+ ByteArrayOutputStream ba_stream = new ByteArrayOutputStream();
+ OutputFormat format = new OutputFormat(doc);
+ format.setIndenting(false);
+ format.setOmitDocumentType(true);
+ format.setOmitXMLDeclaration(true);
+ StringWriter writer = new StringWriter();
+ XMLSerializer serial = new XMLSerializer(writer,format);
+ serial.serialize(doc);
+ transformer.transform(new StreamSource(new ByteArrayInputStream(writer.toString().getBytes())), new StreamResult(ba_stream));
+ //Prepares the object to be returned
+ StringBuffer buffer = new StringBuffer();
+ try {
+ InputStreamReader isr = new InputStreamReader( new ByteArrayInputStream(ba_stream.toByteArray()),
+ "UTF8");
+ Reader in2 = new BufferedReader(isr);
+ int ch;
+ while ((ch = in2.read()) > -1) {
+ buffer.append((char)ch);
+ }
+ in2.close();
+ return buffer.toString();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ catch (Exception e) {
+ e.printStackTrace();
+ }
+ return null;
+ }
+}
diff --git a/src/org/gcube/application/framework/core/util/UserCredential.java b/src/org/gcube/application/framework/core/util/UserCredential.java
new file mode 100644
index 0000000..7e44103
--- /dev/null
+++ b/src/org/gcube/application/framework/core/util/UserCredential.java
@@ -0,0 +1,42 @@
+package org.gcube.application.framework.core.util;
+
+import java.io.File;
+
+import org.gcube.vomanagement.vomsAdmin.impl.VOMSAdminImpl;
+import org.gcube.vomanagement.vomsClient.impl.CredentialsManagerImpl;
+import org.gridforum.jgss.ExtendedGSSCredential;
+
+/**
+ * @author Valia Tsagkalidou (NKUA)
+ *
+ */
+public class UserCredential {
+ /**
+ * Retrieves credential for users
+ * @param username the user name for which it will retrieve credential
+ * @param DLname DLname
+ * @return the GSS Credential
+ */
+ public static ExtendedGSSCredential getCredential(String username, String DLname)
+ {
+ CredentialsManagerImpl man = null;
+ try {
+ String sharedDir = Settings.getInstance().getProperty("sharedDir");
+ System.out.println("file " + sharedDir + "/vomsAPI.properties exists: "+ new File(sharedDir + "/vomsAPI.properties").exists());
+ man = new CredentialsManagerImpl(sharedDir + "/vomsAPI.properties");
+ // VOMSAdminImpl vomsAdm = new VOMSAdminImpl(sharedDir + "/vomsAPI.properties");
+ // man = new CredentialsManagerImpl(vomsAdm);
+ } catch (Exception e1) {
+ e1.printStackTrace();
+ }
+ ExtendedGSSCredential cred = null;
+ try {
+ //TODO: put a real password there...
+ cred = man.getCredentials(username, "", DLname);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ return cred;
+ }
+
+}