You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
341 lines
12 KiB
Java
341 lines
12 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: ManagementUtils.java
|
|
****************************************************************************
|
|
* @author <a href="mailto:daniele.strollo@isti.cnr.it">Daniele Strollo</a>
|
|
***************************************************************************/
|
|
|
|
package org.gcube.resourcemanagement.support.server.managers.resources;
|
|
|
|
import java.io.File;
|
|
import java.rmi.RemoteException;
|
|
import java.util.List;
|
|
import java.util.Vector;
|
|
|
|
import org.gcube.common.core.faults.GCUBEFault;
|
|
import org.gcube.common.core.informationsystem.client.AtomicCondition;
|
|
import org.gcube.common.core.informationsystem.client.queries.GCUBEServiceQuery;
|
|
import org.gcube.common.core.resources.GCUBEResource;
|
|
import org.gcube.common.core.resources.GCUBEService;
|
|
import org.gcube.common.core.scope.GCUBEScope;
|
|
import org.gcube.common.core.scope.GCUBEScope.Type;
|
|
import org.gcube.resourcemanagement.support.server.exceptions.AbstractResourceException;
|
|
import org.gcube.resourcemanagement.support.server.exceptions.ResourceAccessException;
|
|
import org.gcube.resourcemanagement.support.server.exceptions.ResourceOperationException;
|
|
import org.gcube.resourcemanagement.support.server.exceptions.ResourceParameterException;
|
|
import org.gcube.resourcemanagement.support.server.managers.scope.ScopeManager;
|
|
import org.gcube.resourcemanagement.support.server.types.AllowedResourceTypes;
|
|
import org.gcube.resourcemanagement.support.server.utils.Assertion;
|
|
import org.gcube.resourcemanagement.support.server.utils.ServerConsole;
|
|
import org.gcube.vremanagement.resourcemanager.stubs.binder.AddResourcesParameters;
|
|
import org.gcube.vremanagement.resourcemanager.stubs.binder.PackageItem;
|
|
import org.gcube.vremanagement.resourcemanager.stubs.binder.ResourceBinderPortType;
|
|
import org.gcube.vremanagement.resourcemanager.stubs.binder.ResourceItem;
|
|
import org.gcube.vremanagement.resourcemanager.stubs.binder.ResourceList;
|
|
import org.gcube.vremanagement.resourcemanager.stubs.binder.SoftwareList;
|
|
|
|
/**
|
|
* A support class containing operations to manage multiple resources.
|
|
* Here are provided the functionalities to delete/addToScope/deploy
|
|
* groups of homogeneous resources.
|
|
* @author Daniele Strollo (ISTI-CNR)
|
|
*/
|
|
public class ManagementUtils {
|
|
private static final String LOG_PREFIX = "[MANAGEMENT-UTILS]";
|
|
|
|
/**
|
|
* Applies the add to scope to multiple resources having the same type.
|
|
* @param type
|
|
* @param resources
|
|
* @param sourceScope
|
|
* @param targetScope
|
|
* @return the generated report ID
|
|
*/
|
|
public static final synchronized String addToExistingScope(
|
|
final AllowedResourceTypes type,
|
|
final String[] resourceIDs,
|
|
final GCUBEScope sourceScope,
|
|
final GCUBEScope targetScope)
|
|
throws Exception {
|
|
ServerConsole.trace(
|
|
LOG_PREFIX,
|
|
"[ADD-ToExistingScope] Adding from scope [" +
|
|
sourceScope.toString() +
|
|
"] to existing scope [" +
|
|
targetScope.toString() +
|
|
"] resources having type " + type.name());
|
|
|
|
// 1 - If not RI or GHN and the scopes are sibling and VO copyFromToVO
|
|
if (!(type == AllowedResourceTypes.GHN) &&
|
|
!(type == AllowedResourceTypes.RunningInstance) &&
|
|
sourceScope.getType() == Type.VO && targetScope.getType() == Type.VO) {
|
|
// Phase 1. retrieve the resource to copy
|
|
//GCUBEResource resStub = this.getGCUBEResource(sourceScope);
|
|
|
|
// Phase 2. Before to register the resource, the scope must be
|
|
// bound to the local GCUBEResource
|
|
String retval = bindToScope(type, resourceIDs, targetScope);
|
|
|
|
// Phase 3. Register to the new VO through the ISPublisher
|
|
// applies a copy of old descriptors bound in other scopes.
|
|
try {
|
|
for (String id : resourceIDs) {
|
|
AbstractResourceManager res = ResourceFactory.createResourceManager(type, id);
|
|
GCUBEResource resStub = res.getGCUBEResource(sourceScope);
|
|
res.getISPublisher().registerGCUBEResource(resStub, targetScope, res.getSecurityManager());
|
|
}
|
|
} catch (Exception e) {
|
|
throw new ResourceAccessException(e.getMessage());
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
// Add a gCube Resource to
|
|
// (i) a VRE scope from the parent VO or
|
|
// (ii) a VO scope from the infrastructure scope
|
|
if (!targetScope.isEnclosedIn(sourceScope)) {
|
|
throw new ResourceOperationException(
|
|
"You are not allowed to apply to this scope. Target scope is not enclosed in the source one.");
|
|
}
|
|
|
|
// 2 - Applies the normal scope binding
|
|
return bindToScope(type, resourceIDs, targetScope);
|
|
}
|
|
|
|
/**
|
|
* Applies the add to scope to multiple resources having the same type.
|
|
* @param type
|
|
* @param resources
|
|
* @param sourceScope
|
|
* @param targetScope
|
|
* @return the generated report ID
|
|
*/
|
|
public static final synchronized String removeFromExistingScope(final AllowedResourceTypes type, final String[] resourceIDs,
|
|
final GCUBEScope sourceScope, final GCUBEScope targetScope) throws Exception {
|
|
|
|
ServerConsole.trace(
|
|
LOG_PREFIX,
|
|
"[REMOVE-FromExistingScope] Removing scope [" +
|
|
sourceScope.toString() +
|
|
"] to existing scope [" +
|
|
targetScope.toString() +
|
|
"] resources having type " + type.name());
|
|
// cannot remove a Scope if its the same
|
|
if (targetScope.toString().compareTo(sourceScope.toString()) == 0) {
|
|
return "You are not allowed to remove this scope. Current and Target scope are the same.";
|
|
}
|
|
AbstractResourceManager resource = ResourceFactory.createResourceManager(type);
|
|
for (String id : resourceIDs) {
|
|
try {
|
|
resource.setID(id);
|
|
resource.delete(targetScope);
|
|
} catch (AbstractResourceException e) {
|
|
ServerConsole.error(LOG_PREFIX, e);
|
|
}
|
|
}
|
|
|
|
return "ACK";
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param type
|
|
* @param resourceIDs
|
|
* @param targetScope
|
|
* @return the ID of generated report
|
|
* @throws AbstractResourceException
|
|
*/
|
|
private static synchronized String bindToScope(
|
|
final AllowedResourceTypes type,
|
|
final String[] resourceIDs,
|
|
final GCUBEScope targetScope)
|
|
throws AbstractResourceException {
|
|
AddResourcesParameters addParam = new AddResourcesParameters();
|
|
ResourceBinderPortType manager = ResourceFactory.createResourceManager(type).getResourceManager(targetScope);
|
|
List<ResourceItem> resToBind = new Vector<ResourceItem>();
|
|
|
|
for (String id : resourceIDs) {
|
|
ResourceItem toAdd = new ResourceItem();
|
|
toAdd.setID(id);
|
|
toAdd.setType(type.name());
|
|
resToBind.add(toAdd);
|
|
}
|
|
ResourceList r = new ResourceList();
|
|
r.setResource(resToBind.toArray(new ResourceItem[]{}));
|
|
addParam.setResources(r);
|
|
addParam.setTargetScope(targetScope.toString());
|
|
|
|
try {
|
|
String reportID = manager.addResources(addParam);
|
|
|
|
ServerConsole.trace(
|
|
LOG_PREFIX,
|
|
"[BIND-SCOPE-EXIT] Applyed Adding of resources " + type.name() + " to scope [" +
|
|
targetScope.toString() + "]... reportID: " + reportID);
|
|
|
|
return reportID;
|
|
} catch (Exception e) {
|
|
ServerConsole.trace(
|
|
LOG_PREFIX,
|
|
"[BIND-SCOPE-EXIT] [FAILURE]");
|
|
throw new ResourceOperationException("During resource::addToScope: " + e.getMessage());
|
|
}
|
|
}
|
|
|
|
public static synchronized void delete(
|
|
final AllowedResourceTypes type,
|
|
final String[] resourceIDs,
|
|
final GCUBEScope scope)
|
|
throws AbstractResourceException {
|
|
AbstractResourceManager resource = ResourceFactory.createResourceManager(type);
|
|
for (String id : resourceIDs) {
|
|
try {
|
|
resource.setID(id);
|
|
resource.delete(scope);
|
|
} catch (AbstractResourceException e) {
|
|
ServerConsole.error(LOG_PREFIX, e);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Makes the deployment of software on a list of ghns.
|
|
* @param ghnsID
|
|
* @param servicesID
|
|
* @return the generated report ID
|
|
* @throws Exception
|
|
*/
|
|
public static final synchronized String deploy(
|
|
final GCUBEScope scope,
|
|
final String[] ghnsID,
|
|
final String[] servicesID)
|
|
throws Exception {
|
|
Assertion<Exception> checker = new Assertion<Exception>();
|
|
checker.validate(ghnsID != null && ghnsID.length != 0, new ResourceParameterException("Invalid ghnsID parameter. It cannot be null or empty."));
|
|
checker.validate(servicesID != null && servicesID.length != 0, new ResourceParameterException("Invalid servicesID parameter. It cannot be null or empty."));
|
|
checker.validate(scope != null, new Exception("Cannot retrieve the scope."));
|
|
|
|
AbstractResourceManager resource = ResourceFactory.createResourceManager(AllowedResourceTypes.Service);
|
|
ResourceBinderPortType manager = ResourceFactory.createResourceManager(AllowedResourceTypes.Service).getResourceManager(scope);
|
|
|
|
System.out.println("\n\n**** These are the service ids to deploy on SCOPE " + scope);
|
|
for (String sid : servicesID) {
|
|
System.out.println(sid);
|
|
}
|
|
System.out.println("\n\n**** These are the gHNs ids to deploy on SCOPE " + scope);
|
|
for (String ghn : ghnsID) {
|
|
System.out.println(ghn);
|
|
}
|
|
|
|
List<PackageItem> serviceProfiles = new Vector<PackageItem>();
|
|
// Retrieves the profiles of services
|
|
final GCUBEServiceQuery query = resource.getISClient().getQuery(GCUBEServiceQuery.class);
|
|
prepareServices: for (String serviceID : servicesID) {
|
|
System.out.println("\n\n**** Query the IsClient to get the profile");
|
|
query.clearConditions();
|
|
query.addAtomicConditions(new AtomicCondition("/ID", serviceID));
|
|
|
|
System.out.println("**** Query : " + query.getExpression());
|
|
|
|
List<GCUBEService> results = resource.getISClient().execute(query, scope);
|
|
|
|
System.out.println("**** results received : " + results.size());
|
|
|
|
GCUBEService ret = null;
|
|
if (results != null && results.size() > 0) {
|
|
ret = results.get(0);
|
|
} else {
|
|
continue prepareServices;
|
|
}
|
|
|
|
if (ret == null ||
|
|
ret.getServiceClass() == null ||
|
|
ret.getServiceName() == null ||
|
|
ret.getVersion() == null) {
|
|
ServerConsole.error(LOG_PREFIX, "found an invalid service profile");
|
|
continue;
|
|
}
|
|
|
|
PackageItem toAdd = new PackageItem();
|
|
|
|
toAdd.setServiceClass(ret.getServiceClass());
|
|
toAdd.setServiceName(ret.getServiceName());
|
|
toAdd.setServiceVersion(ret.getVersion());
|
|
if (ret.getPackages().size() == 1) {
|
|
toAdd.setPackageName(ret.getPackages().get(0).getName());
|
|
toAdd.setPackageVersion(ret.getPackages().get(0).getVersion());
|
|
} else {
|
|
for (org.gcube.common.core.resources.service.Package p : ret.getPackages()) {
|
|
if (p.getClass().isAssignableFrom(org.gcube.common.core.resources.service.MainPackage.class)) {
|
|
toAdd.setPackageName(p.getName());
|
|
toAdd.setPackageVersion(p.getVersion());
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
serviceProfiles.add(toAdd);
|
|
}
|
|
|
|
SoftwareList serviceList = new SoftwareList();
|
|
serviceList.setSuggestedTargetGHNNames(ghnsID);
|
|
serviceList.setSoftware(serviceProfiles.toArray(new PackageItem[0]));
|
|
|
|
AddResourcesParameters addResourcesParameters = new AddResourcesParameters();
|
|
addResourcesParameters.setSoftware(serviceList);
|
|
addResourcesParameters.setTargetScope(scope.toString());
|
|
|
|
System.out.println("\n\n**** These is the ServiceList i pass to ResourceManagerPortType: ");
|
|
for (int i = 0; i < serviceList.getSoftware().length; i++) {
|
|
System.out.println(serviceList.getSoftware()[i]);
|
|
}
|
|
|
|
String id = "";
|
|
try {
|
|
id = manager.addResources(addResourcesParameters);
|
|
ServerConsole.debug(LOG_PREFIX, "Report ID = " + id);
|
|
} catch (GCUBEFault e) {
|
|
ServerConsole.error(LOG_PREFIX, "during deployment.", e);
|
|
throw e;
|
|
} catch (RemoteException e) {
|
|
ServerConsole.error(LOG_PREFIX, "during deployment.", e);
|
|
throw e;
|
|
}
|
|
System.out.println("Returning.... no exceptions");
|
|
return id;
|
|
}
|
|
|
|
public static final void main(final String[] args) {
|
|
List<String> ids = new Vector<String>();
|
|
ids.add(null);
|
|
ids.add("id2");
|
|
ids.add(null);
|
|
|
|
ScopeManager.setScopeConfigFile("test-suite" + File.separator + "scopes" + File.separator + "scopedata.xml");
|
|
|
|
try {
|
|
|
|
|
|
ManagementUtils.delete(AllowedResourceTypes.GenericResource,
|
|
new String[]{
|
|
"3f7384a0-d51c-11df-80cc-ece35605c26c",
|
|
"975419b0-d2e1-11df-b0ed-f8e6e669b8ad",
|
|
null,
|
|
"test"
|
|
},
|
|
ScopeManager.getScope("/gcube/devsec/devVRE"));
|
|
} catch (Exception e) {
|
|
ServerConsole.error(LOG_PREFIX, e);
|
|
}
|
|
}
|
|
}
|