742 lines
26 KiB
Java
742 lines
26 KiB
Java
/****************************************************************************
|
|
* This software is part of the gCube Project.
|
|
* Site: http://www.gcube-system.org/
|
|
****************************************************************************
|
|
* The gCube/gCore software is licensed as Free Open Source software
|
|
* conveying to the EUPL (http://ec.europa.eu/idabc/eupl).
|
|
* The software and documentation is provided by its authors/distributors
|
|
* "as is" and no expressed or
|
|
* implied warranty is given for its use, quality or fitness for a
|
|
* particular case.
|
|
****************************************************************************
|
|
* Filename: ServiceProxyImpl.java
|
|
****************************************************************************
|
|
* @author <a href="mailto:daniele.strollo@isti.cnr.it">Daniele Strollo</a>
|
|
***************************************************************************/
|
|
|
|
package org.gcube.portlets.admin.resourcemanagement.server;
|
|
|
|
import static org.gcube.resources.discovery.icclient.ICFactory.client;
|
|
|
|
import java.io.File;
|
|
import java.io.StringReader;
|
|
import java.security.InvalidParameterException;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.LinkedHashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Vector;
|
|
|
|
import javax.servlet.http.HttpSession;
|
|
import javax.xml.parsers.DocumentBuilder;
|
|
import javax.xml.parsers.DocumentBuilderFactory;
|
|
|
|
import org.gcube.common.resources.gcore.utils.XPathHelper;
|
|
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.portlets.admin.resourcemanagement.client.remote.ServiceProxy;
|
|
import org.gcube.portlets.admin.resourcemanagement.server.gcube.services.StatusHandler;
|
|
import org.gcube.portlets.admin.resourcemanagement.server.gcube.services.configuration.ConfigurationLoader;
|
|
import org.gcube.portlets.admin.resourcemanagement.shared.utils.BCrypt;
|
|
import org.gcube.resourcemanagement.support.client.utils.CurrentStatus;
|
|
import org.gcube.resourcemanagement.support.client.views.ResourceTypeDecorator;
|
|
import org.gcube.resourcemanagement.support.server.gcube.CacheManager;
|
|
import org.gcube.resourcemanagement.support.server.gcube.ISClientRequester;
|
|
import org.gcube.resourcemanagement.support.server.gcube.queries.QueryLoader;
|
|
import org.gcube.resourcemanagement.support.server.gcube.queries.QueryLocation;
|
|
import org.gcube.resourcemanagement.support.server.managers.resources.GenericResourceManager;
|
|
import org.gcube.resourcemanagement.support.server.managers.resources.ManagementUtils;
|
|
import org.gcube.resourcemanagement.support.server.managers.resources.ResourceFactory;
|
|
import org.gcube.resourcemanagement.support.server.managers.scope.ScopeManager;
|
|
import org.gcube.resourcemanagement.support.server.types.AllowedResourceTypes;
|
|
import org.gcube.resourcemanagement.support.server.utils.ServerConsole;
|
|
import org.gcube.resourcemanagement.support.shared.exceptions.InvalidPermissionsException;
|
|
import org.gcube.resourcemanagement.support.shared.operations.SupportedOperations;
|
|
import org.gcube.resourcemanagement.support.shared.plugins.GenericResourcePlugin;
|
|
import org.gcube.resourcemanagement.support.shared.types.Tuple;
|
|
import org.gcube.resourcemanagement.support.shared.types.UserGroup;
|
|
import org.gcube.resourcemanagement.support.shared.types.datamodel.CompleteResourceProfile;
|
|
import org.gcube.resourcemanagement.support.shared.types.datamodel.ResourceDescriptor;
|
|
import org.gcube.resourcemanagement.support.shared.util.Assertion;
|
|
import org.gcube.resourcemanagement.support.shared.util.Configuration;
|
|
import org.gcube.resources.discovery.client.api.DiscoveryClient;
|
|
import org.gcube.resources.discovery.client.queries.impl.QueryTemplate;
|
|
import org.gcube.vomanagement.usermanagement.GroupManager;
|
|
import org.gcube.vomanagement.usermanagement.impl.LiferayGroupManager;
|
|
import org.gcube.vomanagement.usermanagement.model.GCubeGroup;
|
|
import org.gcube.vomanagement.usermanagement.model.VirtualGroup;
|
|
import org.gcube.vremanagement.resourcemanager.client.RMReportingLibrary;
|
|
import org.w3c.dom.Node;
|
|
import org.xml.sax.InputSource;
|
|
|
|
import com.google.gwt.user.server.rpc.RemoteServiceServlet;
|
|
import com.liferay.portal.kernel.exception.PortalException;
|
|
import com.liferay.portal.kernel.exception.SystemException;
|
|
import com.liferay.portal.model.Group;
|
|
import com.liferay.portal.model.LayoutSet;
|
|
import com.liferay.portal.service.GroupLocalServiceUtil;
|
|
import com.liferay.portal.service.VirtualHostLocalServiceUtil;
|
|
import com.liferay.portal.util.PortalUtil;
|
|
|
|
/**
|
|
* @author Daniele Strollo
|
|
* @author Massimiliano Assante (ISTI-CNR)
|
|
*
|
|
*
|
|
*/
|
|
@SuppressWarnings("serial")
|
|
public class ServiceProxyImpl extends RemoteServiceServlet implements ServiceProxy {
|
|
private static final String LOG_PREFIX = "[SERVICE-IMPL]";
|
|
|
|
public final void emptyCache() {
|
|
ISClientRequester.emptyCache();
|
|
}
|
|
|
|
public final void setUseCache(final boolean flag) {
|
|
this.getCurrentStatus().setUseCache(flag);
|
|
}
|
|
|
|
public final void setSuperUser(final boolean superUser) {
|
|
if (superUser && this.getCurrentStatus().getCredentials() == UserGroup.DEBUG) {
|
|
this.getCurrentStatus().setCredentials(UserGroup.ADMIN);
|
|
} else {
|
|
this.getCurrentStatus().setCredentials(UserGroup.DEBUG);
|
|
}
|
|
initScopes(true);
|
|
}
|
|
|
|
/**
|
|
* Called by portlet at module instantiation
|
|
*/
|
|
public final CurrentStatus initStatus() {
|
|
ServerConsole.trace(LOG_PREFIX, "[INIT-STATUS] initializing config parameters");
|
|
|
|
ServerConsole.info(LOG_PREFIX, "Clearing status");
|
|
StatusHandler.clearStatus(getHttpSession());
|
|
|
|
ConfigurationLoader.setConfigurationFile(getPropertiesFSPath() + File.separator + "resourcemanagement.properties");
|
|
return this.getCurrentStatus();
|
|
}
|
|
|
|
private HttpSession getHttpSession() {
|
|
return this.getThreadLocalRequest().getSession();
|
|
}
|
|
|
|
public final void initScopes(final boolean doClean) {
|
|
ServerConsole.trace(LOG_PREFIX, "[INIT-SCOPES] initializing scopes from: " + this.getScopeDataPath());
|
|
|
|
// Updates the scopes
|
|
try {
|
|
ScopeManager.setScopeConfigFile(this.getScopeDataPath());
|
|
if (doClean) {
|
|
ScopeManager.clear();
|
|
}
|
|
ScopeManager.update();
|
|
} catch (Exception e) {
|
|
ServerConsole.error(LOG_PREFIX, "During scope caching", e);
|
|
}
|
|
|
|
}
|
|
|
|
private String getServletFSPath() {
|
|
return this.getServletContext().getRealPath("") + File.separator + "WEB-INF";
|
|
}
|
|
|
|
private String getPropertiesFSPath() {
|
|
return this.getServletContext().getRealPath("") + File.separator + "conf";
|
|
}
|
|
|
|
private String getScopeDataPath() {
|
|
String startDirectory = getServletFSPath();
|
|
return startDirectory + File.separator + "xml" + File.separator +
|
|
((this.getCurrentStatus().getCredentials() == UserGroup.ADMIN) ?
|
|
"scopedata_admin.xml" :
|
|
"scopedata.xml");
|
|
}
|
|
|
|
private String getXML2HTMLMapping() {
|
|
String startDirectory = getServletFSPath();
|
|
return startDirectory + File.separator + "xml" + File.separator + "xmlverbatim.xsl";
|
|
}
|
|
|
|
|
|
public final Tuple<String> addResourcesToScope(
|
|
final String resType,
|
|
final List<String> resourceIDs,
|
|
final String scope)
|
|
throws Exception {
|
|
Assertion<Exception> checker = new Assertion<Exception>();
|
|
|
|
CurrentStatus status = this.getCurrentStatus();
|
|
|
|
checker.validate(SupportedOperations.ADD_TO_SCOPE.isAllowed(status.getCredentials()),
|
|
new Exception("User not allowed to request this operation"));
|
|
checker.validate(resType != null && resType.trim().length() > 0, new Exception("Invalid parameter type"));
|
|
checker.validate(resourceIDs != null && resourceIDs.size() > 0, new Exception("Invalid parameter type"));
|
|
checker.validate(scope != null && scope.trim().length() > 0, new Exception("Invalid parameter type"));
|
|
|
|
|
|
AllowedResourceTypes type = AllowedResourceTypes.valueOf(resType);
|
|
ScopeBean targetScope = new ScopeBean(scope);
|
|
ScopeBean sourceScope = new ScopeBean(status.getCurrentScope());
|
|
//new check
|
|
if (sourceScope.type() == Type.INFRASTRUCTURE && targetScope.type() == Type.VRE ) {
|
|
throw new Exception("Because adding a VRE Context from the Root VO is not allowed.");
|
|
}
|
|
|
|
|
|
String reportID = ManagementUtils.addToExistingScope(type,
|
|
resourceIDs.toArray(new String[]{}),
|
|
sourceScope,
|
|
targetScope);
|
|
|
|
RMReportingLibrary manager =
|
|
ResourceFactory.createResourceManager(type).getReportResourceManager(targetScope.toString());
|
|
|
|
String xmlReport = manager.getReport(reportID);
|
|
String mappingPath = this.getXML2HTMLMapping();
|
|
String htmlReport = ISClientRequester.XML2HTML(xmlReport, mappingPath);
|
|
return new Tuple<String>(
|
|
reportID,
|
|
resType,
|
|
xmlReport,
|
|
htmlReport);
|
|
}
|
|
/**
|
|
* REMOVE FROM SCOPE
|
|
*/
|
|
public final Tuple<String> removeResourcesFromScope(
|
|
final String resType,
|
|
final List<String> resourceIDs,
|
|
final String scope)
|
|
throws Exception {
|
|
Assertion<Exception> checker = new Assertion<Exception>();
|
|
|
|
CurrentStatus status = this.getCurrentStatus();
|
|
|
|
checker.validate(SupportedOperations.ADD_TO_SCOPE.isAllowed(status.getCredentials()),
|
|
new Exception("User not allowed to request this operation"));
|
|
checker.validate(resType != null && resType.trim().length() > 0, new Exception("Invalid parameter type"));
|
|
checker.validate(resourceIDs != null && resourceIDs.size() > 0, new Exception("Invalid parameter type"));
|
|
checker.validate(scope != null && scope.trim().length() > 0, new Exception("Invalid parameter type"));
|
|
|
|
AllowedResourceTypes type = AllowedResourceTypes.valueOf(resType);
|
|
ScopeBean targetScope = new ScopeBean(scope);
|
|
ScopeBean sourceScope = new ScopeBean(status.getCurrentScope());
|
|
|
|
//new check
|
|
if (sourceScope.type() == Type.INFRASTRUCTURE && targetScope.type() == Type.VRE ) {
|
|
throw new Exception("Because removing a VRE Context from the Root VO is not allowed.");
|
|
}
|
|
|
|
String reportID = ManagementUtils.removeFromExistingScope(type,
|
|
resourceIDs.toArray(new String[]{}),
|
|
sourceScope,
|
|
targetScope);
|
|
|
|
|
|
RMReportingLibrary manager =
|
|
ResourceFactory.createResourceManager(type).getReportResourceManager(targetScope.toString());
|
|
|
|
String xmlReport = manager.getReport(reportID);
|
|
String mappingPath = this.getXML2HTMLMapping();
|
|
String htmlReport = ISClientRequester.XML2HTML(xmlReport, mappingPath);
|
|
|
|
return new Tuple<String>(
|
|
reportID,
|
|
resType,
|
|
xmlReport,
|
|
htmlReport);
|
|
}
|
|
|
|
public final String deploy(final List<String> ghnsID, final List<String> servicesID) throws Exception {
|
|
try {
|
|
ScopeBean sourceScope = new ScopeBean(this.getCurrentStatus().getCurrentScope());
|
|
String[] param1 = ghnsID.toArray(new String[0]);
|
|
String[] param2 = servicesID.toArray(new String[0]);
|
|
return ManagementUtils.deploy(sourceScope, param1, param2);
|
|
} catch (Exception e) {
|
|
ServerConsole.error(LOG_PREFIX, "During service deployment", e);
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
public final Tuple<String> checkDeployStatus(final String scope, final String deployID) throws Exception {
|
|
if (SupportedOperations.SERVICE_GET_REPORT.isAllowed(this.getCurrentStatus().getCredentials())) {
|
|
ScopeBean sourceScope = ScopeManager.getScope(scope);
|
|
RMReportingLibrary manager =
|
|
ResourceFactory.createResourceManager(AllowedResourceTypes.Service).getReportResourceManager(sourceScope.toString());
|
|
String xmlReport = manager.getReport(deployID);
|
|
String mappingPath = this.getXML2HTMLMapping();
|
|
String htmlReport = ISClientRequester.XML2HTML(xmlReport, mappingPath);
|
|
return new Tuple<String>(deployID, xmlReport, htmlReport);
|
|
} else {
|
|
throw new Exception("The current user is not allowed to request the operation");
|
|
}
|
|
}
|
|
|
|
public final List<String> getAvailableScopes() {
|
|
ServerConsole.trace(LOG_PREFIX, "[GET-SCOPES] getting available scopes");
|
|
Vector<String> retval = new Vector<String>();
|
|
try {
|
|
Map<String, ScopeBean> scopes = ScopeManager.getAvailableScopes();
|
|
for (ScopeBean scope : scopes.values())
|
|
retval.add(scope.toString());
|
|
|
|
return retval;
|
|
} catch (Exception e) {
|
|
retval.add("/gcube");
|
|
retval.add("/gcube/devsec");
|
|
e.printStackTrace();
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
|
|
public final List<String> getAvailableAddScopes() {
|
|
List<String> retval = new Vector<String>();
|
|
try {
|
|
ScopeBean currScope = ScopeManager.getScope(this.getCurrentStatus().getCurrentScope());
|
|
List<String> scopes = this.getAvailableScopes();
|
|
for (String scope : scopes) {
|
|
if (scope.contains(currScope.toString())) {
|
|
retval.add(scope);
|
|
}
|
|
}
|
|
return retval;
|
|
} catch (Exception e) {
|
|
ServerConsole.error(LOG_PREFIX, e);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public final HashMap<String, ArrayList<String>> getResourceTypeTree(final String scope) throws Exception {
|
|
try {
|
|
ScopeBean gscope = new ScopeBean(scope);
|
|
HashMap<String, ArrayList<String>> results = ISClientRequester.getResourcesTree(getCacheManager(this.getCurrentStatus()), gscope);
|
|
return results;
|
|
} catch (Exception e) {
|
|
ServerConsole.error(LOG_PREFIX, "applying resource get", e);
|
|
throw e;
|
|
}
|
|
}
|
|
|
|
public final List<String> getRelatedResources(final String type, final String id, final String scope)
|
|
{
|
|
try {
|
|
return ISClientRequester.getRelatedResources(
|
|
getCacheManager(this.getCurrentStatus()),
|
|
type,
|
|
id,
|
|
new ScopeBean(scope)
|
|
);
|
|
} catch (Exception e) {
|
|
ServerConsole.error(LOG_PREFIX, e);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public final List<String> getResourcesByType(final String scope, final String type)
|
|
{
|
|
try {
|
|
return ISClientRequester.getResourcesByType(
|
|
getCacheManager(this.getCurrentStatus()),
|
|
new ScopeBean(scope), type, null);
|
|
} catch (Exception e) {
|
|
ServerConsole.error(LOG_PREFIX, e);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public final ResourceDescriptor getGenericResourceDescriptor(final String scope, final String resID) throws Exception {
|
|
return this.getDescriptor(ScopeManager.getScope(scope), resID);
|
|
}
|
|
|
|
private ResourceDescriptor getDescriptor(final ScopeBean scope, final String resID) throws Exception {
|
|
|
|
|
|
//set the scope
|
|
String currScope = ScopeProvider.instance.get();
|
|
ScopeProvider.instance.set(scope.toString());
|
|
|
|
QueryTemplate isQuery = null;
|
|
DiscoveryClient<String> client = client();
|
|
|
|
isQuery = new QueryTemplate(QueryLoader.getQuery(QueryLocation.GET_RESOURCE_BYID));
|
|
|
|
isQuery.addParameter("RES_ID", resID);
|
|
isQuery.addParameter("RES_TYPE", ResourceTypeDecorator.GenericResource.name());
|
|
|
|
List<String> results = client.submit(isQuery);
|
|
|
|
if (results != null && results.size() > 0) {
|
|
ResourceDescriptor retval = new ResourceDescriptor();
|
|
|
|
List<String> currValue = null;
|
|
DocumentBuilder docBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
|
|
Node node = docBuilder.parse(new InputSource(new StringReader(results.get(0)))).getDocumentElement();
|
|
XPathHelper helper = new XPathHelper(node);
|
|
|
|
currValue = helper.evaluate("/Resource/ID/text()");
|
|
if (currValue != null && currValue.size() > 0) {
|
|
retval.setID(currValue.get(0));
|
|
}
|
|
currValue = helper.evaluate("/Resource/Profile/Name/text()");
|
|
if (currValue != null && currValue.size() > 0) {
|
|
retval.setName(currValue.get(0));
|
|
}
|
|
|
|
currValue = helper.evaluate("/Resource/Profile/Body/node()");
|
|
if (currValue != null && currValue.size() > 0) {
|
|
StringBuilder bodytext = new StringBuilder();
|
|
for (String line : currValue) {
|
|
bodytext.append(line);
|
|
}
|
|
retval.set("Body", bodytext.toString().trim());
|
|
} else {
|
|
retval.set("Body", "");
|
|
}
|
|
|
|
|
|
currValue = helper.evaluate("/Resource/Profile/Description/text()");
|
|
if (currValue != null && currValue.size() > 0) {
|
|
retval.set("Description", currValue.get(0));
|
|
} else {
|
|
retval.set("Description", "");
|
|
}
|
|
|
|
|
|
currValue = helper.evaluate("/Resource/Profile/SecondaryType/text()");
|
|
if (currValue != null && currValue.size() > 0) {
|
|
retval.set("SecondaryType", currValue.get(0));
|
|
} else {
|
|
retval.set("SecondaryType", "");
|
|
}
|
|
|
|
return retval;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public final List<ResourceDescriptor> getResourcesModel(final String scope, final String type, final String subType, final List<Tuple<String>> additionalMaps)
|
|
throws Exception {
|
|
if (scope == null || type == null) {
|
|
return null;
|
|
}
|
|
return ISClientRequester.getResourceModels(new ScopeBean(scope), type, subType, additionalMaps);
|
|
}
|
|
|
|
|
|
public final List<String> getWSResources(final String scope) {
|
|
try {
|
|
return ISClientRequester.getWSResources(new ScopeBean(scope));
|
|
} catch (Exception e) {
|
|
ServerConsole.error(LOG_PREFIX, e);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public final List<String> getResourcesBySubType(final String scope, final String type, final String subtype) {
|
|
try {
|
|
return ISClientRequester.getResourcesByType(
|
|
getCacheManager(this.getCurrentStatus()),
|
|
new ScopeBean(scope), type, subtype);
|
|
} catch (Exception e) {
|
|
ServerConsole.error(LOG_PREFIX, e);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public final CompleteResourceProfile getResourceByID(final String scope, final String type, final String resID) {
|
|
try {
|
|
CompleteResourceProfile profile = ISClientRequester.getResourceByID(this.getXML2HTMLMapping(), new ScopeBean(scope), type, resID);
|
|
System.out.println("****CompleteResourceProfile getResourceByID("+scope+","+type+","+resID+") *****\n\n");
|
|
System.out.println("Resource found XML:"+profile.getXmlRepresentation());
|
|
return profile;
|
|
} catch (Exception e) {
|
|
ServerConsole.error(LOG_PREFIX, e);
|
|
return null;
|
|
}
|
|
|
|
}
|
|
|
|
public final String createGenericResource(
|
|
final String ID,
|
|
final String name,
|
|
final String description,
|
|
final String body,
|
|
final String subType)
|
|
throws Exception {
|
|
// Check permissions
|
|
Assertion<InvalidPermissionsException> checker = new Assertion<InvalidPermissionsException>();
|
|
checker.validate(
|
|
SupportedOperations.GENERIC_RESOURCE_CREATE.isAllowed(this.getCurrentStatus().getCredentials()),
|
|
new InvalidPermissionsException("The user is not allowed to execute the following operation"));
|
|
|
|
return GenericResourceManager.create(
|
|
ID,
|
|
new ScopeBean(this.getCurrentStatus().getCurrentScope()),
|
|
name,
|
|
description,
|
|
body,
|
|
subType);
|
|
}
|
|
|
|
public final void updateGenericResource(
|
|
final String ID,
|
|
final String name,
|
|
final String description,
|
|
final String body,
|
|
final String subType)
|
|
throws Exception {
|
|
// Check permissions
|
|
Assertion<InvalidPermissionsException> checker = new Assertion<InvalidPermissionsException>();
|
|
checker.validate(
|
|
SupportedOperations.GENERIC_RESOURCE_EDIT.isAllowed(this.getCurrentStatus().getCredentials()),
|
|
new InvalidPermissionsException("The user is not allowed to execute the following operation"));
|
|
|
|
ScopeBean sourceScope = new ScopeBean(this.getCurrentStatus().getCurrentScope());
|
|
GenericResourceManager resource = new GenericResourceManager(ID);
|
|
resource.update(name, description, body, subType, sourceScope);
|
|
}
|
|
|
|
public final void setCurrentScope(final String scope) {
|
|
this.getCurrentStatus().setCurrentScope(scope);
|
|
}
|
|
|
|
public final Map<String, GenericResourcePlugin> getGenericResourcePlugins() throws Exception {
|
|
return ISClientRequester.getGenericResourcePlugins(ScopeManager.getScope(this.getCurrentStatus().getCurrentScope()));
|
|
}
|
|
|
|
private CurrentStatus getCurrentStatus() {
|
|
return StatusHandler.getStatus(this.getHttpSession());
|
|
}
|
|
|
|
private CacheManager getCacheManager(CurrentStatus status) {
|
|
CacheManager cm = new CacheManager();
|
|
cm.setUseCache(status.useCache());
|
|
return cm;
|
|
}
|
|
/***********************************************************
|
|
* RESOURCE OPERATIONS
|
|
* @throws InvalidParameterException
|
|
**********************************************************/
|
|
public final void doOperation(
|
|
final SupportedOperations opCode,
|
|
final String scope,
|
|
final List<ResourceDescriptor> resources)
|
|
throws Exception {
|
|
try {
|
|
ResourceCommands.doOperation(
|
|
this.getCurrentStatus(),
|
|
opCode, scope, resources);
|
|
} catch (final Exception e) {
|
|
ServerConsole.error(LOG_PREFIX, e);
|
|
throw new Exception(e.getMessage());
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean enableSuperUserMode(String code) {
|
|
String ipAddressCaller = getThreadLocalRequest().getRemoteAddr();
|
|
boolean matched = BCrypt.checkpw(code, Configuration.CODE);
|
|
if (matched)
|
|
ServerConsole.info(LOG_PREFIX, "AUTHORISED SUPER USER MODE, IP: " + ipAddressCaller);
|
|
else
|
|
ServerConsole.info(LOG_PREFIX, "FAILED ATTEMPT SUPER USER MODE FROM IP: " + ipAddressCaller);
|
|
return matched;
|
|
}
|
|
/**
|
|
* return the list of URLS for a given VRE Context
|
|
*/
|
|
@Override
|
|
public List<String> getGatewayURLsGivenVREContext(String vreContext) {
|
|
|
|
List<Gateway> theGateways= getGateways(new LiferayGroupManager());
|
|
List<String> gatewayURLs = new ArrayList<>();
|
|
for (Gateway gateway : theGateways) {
|
|
LayoutSet layoutSet = null;
|
|
if (gateway.getSite().hasPublicLayouts())
|
|
layoutSet = gateway.getSite().getPublicLayoutSet();
|
|
else
|
|
layoutSet = gateway.getSite().getPrivateLayoutSet();
|
|
final long companyId = PortalUtil.getDefaultCompanyId();
|
|
long layoutSetId = layoutSet.getLayoutSetId();
|
|
String vHost = "";
|
|
try {
|
|
vHost = VirtualHostLocalServiceUtil.getVirtualHost(companyId, layoutSetId).getHostname();
|
|
} catch (PortalException | SystemException e) {
|
|
e.printStackTrace();
|
|
}
|
|
String theURL = "https://"+vHost+"/";
|
|
gatewayURLs.add(theURL);
|
|
}
|
|
return gatewayURLs;
|
|
}
|
|
|
|
|
|
private List<Gateway> getGateways(GroupManager groupsManager) {
|
|
List<Gateway> toReturn = new ArrayList<>();
|
|
try{
|
|
List<Group> candidateGateways = GroupLocalServiceUtil.getGroups(org.gcube.vomanagement.usermanagement.util.ManagementUtils.getCompany().getCompanyId(), 0, true);
|
|
// real gateways have no children as well
|
|
for (Group group : candidateGateways) {
|
|
List<Group> children = group.getChildren(true);
|
|
if(children == null || children.isEmpty())
|
|
if(! (group.getFriendlyURL().equals("/guest") || group.getFriendlyURL().equals("/global") )) {// skipping these sites
|
|
ArrayList<String> theVRENames = new ArrayList<>();
|
|
LinkedHashMap<VRECategory, ArrayList<VRE>> sites = getPortalSitesMappedToVRE(group.getGroupId(), groupsManager);
|
|
for (VRECategory cat : sites.keySet()) {
|
|
for (VRE vre : sites.get(cat)) {
|
|
theVRENames.add(vre.getName());
|
|
}
|
|
}
|
|
toReturn.add(new Gateway(group, theVRENames));
|
|
ServerConsole.debug("Gateway " + group.getName() + " has " + theVRENames.size() + " VREs");
|
|
}
|
|
}
|
|
} catch(Exception e){
|
|
ServerConsole.error("Failed to retrieve the list of gateways", e);
|
|
return null;
|
|
}
|
|
return toReturn;
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @return the Virtual groups with their VREs in the order estabilished in
|
|
* the LR Control Panel
|
|
*/
|
|
private LinkedHashMap<VRECategory, ArrayList<VRE>> getPortalSitesMappedToVRE(long currentSiteGroupId, GroupManager groupsManager) throws Exception {
|
|
|
|
LinkedHashMap<VRECategory, ArrayList<VRE>> toReturn = new LinkedHashMap<VRECategory, ArrayList<VRE>>();
|
|
|
|
List<VirtualGroup> currentSiteVGroups = groupsManager.getVirtualGroups(currentSiteGroupId);
|
|
|
|
for (VirtualGroup vg : currentSiteVGroups) {
|
|
ArrayList<VRE> toCreate = new ArrayList<VRE>();
|
|
VRECategory cat = new VRECategory(1L, vg.getName(), vg.getDescription());
|
|
toReturn.put(cat, toCreate);
|
|
}
|
|
|
|
GCubeGroup rootGroupVO = groupsManager.getRootVO();
|
|
|
|
try {
|
|
ServerConsole.debug("root: " + rootGroupVO.getGroupName());
|
|
} catch (NullPointerException e) {
|
|
ServerConsole.warn(
|
|
"Cannot find root organziation, please check gcube-data.properties file in $CATALINA_HOME/conf folder, unless your installing the Bundle");
|
|
return toReturn;
|
|
}
|
|
|
|
// for each root sub organizations (VO)
|
|
for (GCubeGroup vOrg : rootGroupVO.getChildren()) {
|
|
for (GCubeGroup vreSite : vOrg.getChildren()) {
|
|
long vreID = vreSite.getGroupId();
|
|
String vreName = vreSite.getGroupName();
|
|
String vreDescription = vreSite.getDescription();
|
|
List<VirtualGroup> vreGroups = groupsManager.getVirtualGroups(vreID);
|
|
for (VirtualGroup vreGroup : vreGroups) {
|
|
for (VRECategory vre : toReturn.keySet()) {
|
|
if (vre.getName().compareTo(vreGroup.getName()) == 0) {
|
|
ArrayList<VRE> toUpdate = toReturn.get(vre);
|
|
VRE toAdd = new VRE(vreName, vreDescription, vreID, "", "");
|
|
toUpdate.add(toAdd);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return toReturn;
|
|
}
|
|
|
|
|
|
private class VRECategory {
|
|
private long categoryID;
|
|
private String name;
|
|
private String description;
|
|
|
|
public VRECategory(long categoryID, String name, String description) {
|
|
super();
|
|
this.categoryID = categoryID;
|
|
this.name = name;
|
|
this.description = description;
|
|
}
|
|
|
|
@SuppressWarnings("unused")
|
|
public long getCategoryID() {
|
|
return categoryID;
|
|
}
|
|
|
|
@SuppressWarnings("unused")
|
|
public String getDescription() {
|
|
return description;
|
|
}
|
|
|
|
public String getName() {
|
|
return name;
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return "VRECategory [categoryID=" + categoryID + ", name=" + name + ", description=" + description + "]";
|
|
}
|
|
|
|
}
|
|
private class VRE implements Comparable<VRE> {
|
|
private String name;
|
|
private String description;
|
|
private long id;
|
|
private String url;
|
|
private String scope;
|
|
|
|
public VRE(String name, String description, long id, String url, String scope) {
|
|
super();
|
|
this.name = name;
|
|
this.description = description;
|
|
this.id = id;
|
|
this.url = url;
|
|
this.scope = scope;
|
|
}
|
|
|
|
@SuppressWarnings("unused")
|
|
public String getDescription() {
|
|
return description;
|
|
}
|
|
|
|
@SuppressWarnings("unused")
|
|
public long getId() {
|
|
return id;
|
|
}
|
|
|
|
public String getName() {
|
|
return name;
|
|
}
|
|
|
|
@SuppressWarnings("unused")
|
|
public String getScope() {
|
|
return scope;
|
|
}
|
|
|
|
@SuppressWarnings("unused")
|
|
public String getUrl() {
|
|
return url;
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return "VRE [name=" + name + ", description=" + description + ", id=" + id + ", url=" + url + ", scope="
|
|
+ scope + "]";
|
|
}
|
|
|
|
@Override
|
|
public int compareTo(VRE vre) {
|
|
return this.getName().compareTo(vre.getName());
|
|
}
|
|
}
|
|
|
|
|
|
}
|