Added unpublish of old ServiceEndpoint published by current ghn which are still on IS

git-svn-id: https://svn.d4science.research-infrastructures.eu/gcube/trunk/vre-management/smart-executor@111939 82a268e6-3cf1-43bd-a215-b396298e98cf
This commit is contained in:
Luca Frosini 2015-02-12 13:40:41 +00:00
parent 7fcda68c0a
commit b096f0145c
1 changed files with 128 additions and 40 deletions

View File

@ -25,9 +25,14 @@ import org.gcube.common.resources.gcore.ServiceEndpoint.Property;
import org.gcube.common.resources.gcore.ServiceEndpoint.Runtime;
import org.gcube.common.resources.gcore.common.Platform;
import org.gcube.common.resources.gcore.utils.Group;
import org.gcube.common.scope.api.ScopeProvider;
import org.gcube.informationsystem.publisher.RegistryPublisherFactory;
import org.gcube.informationsystem.publisher.ScopedPublisher;
import org.gcube.informationsystem.publisher.exception.RegistryNotFoundException;
import org.gcube.resources.discovery.client.api.DiscoveryClient;
import org.gcube.resources.discovery.client.queries.api.SimpleQuery;
import org.gcube.resources.discovery.icclient.ICFactory;
import org.gcube.smartgears.configuration.container.ContainerConfiguration;
import org.gcube.smartgears.context.application.ApplicationContext;
import org.gcube.smartgears.handlers.application.ApplicationLifecycleEvent;
import org.gcube.smartgears.handlers.application.ApplicationLifecycleHandler;
@ -119,7 +124,7 @@ public class SmartExecutorInitalizator extends ApplicationLifecycleHandler {
ScopedPublisher scopedPublisher = RegistryPublisherFactory.scopedPublisher();
try {
logger.debug(String.format("Trying to publish\n%s", stringWriter.toString()));
logger.debug("Trying to publish\n{} to {}", stringWriter.toString(), scopes);
scopedPublisher.create(resource, scopes);
} catch (RegistryNotFoundException e) {
logger.error("The resource was not published", e);
@ -139,17 +144,63 @@ public class SmartExecutorInitalizator extends ApplicationLifecycleHandler {
ScopedPublisher scopedPublisher = RegistryPublisherFactory.scopedPublisher();
try {
logger.debug(String.format("Trying to unpublish\n%s", stringWriter.toString()));
logger.debug("Trying to unpublish\n{} from {}", stringWriter, scopes);
scopedPublisher.remove(resource, scopes);
logger.debug("Unpublish request executed successfully");
} catch (RegistryNotFoundException e) {
logger.error("The resource was not unpublished", e);
throw e;
}
}
/**
* Return the parsed version string as array of short.
* @param version the version as String
* @param wantedLenght if the length is equals to dot (.) separated
* number in the string. Otherwise the version is padded or truncated to
* the required version
* @return the parsed version as array of short. If on slicing some of the
* version cannot be parsed as short 1 is used for the first number, 0 is
* used instead or for padding
*/
private static short[] getVersionSlice(String version, int wantedLenght){
logger.trace("Trying to parse {}", version);
short[] versionSlices = new short[wantedLenght];
for(int j=0; j<wantedLenght; j++){
versionSlices[j] = (short) (j==0 ? 1 : 0);
}
try {
String[] stringSlices = version.split("[.-]");
for(int i=0; i<stringSlices.length; i++){
logger.trace("Parsing version slice n. {} wich is '{}'", i, stringSlices[i]);
if(i>=wantedLenght){
break;
}
try {
short n = Short.parseShort(stringSlices[i]);
versionSlices[i] = n;
logger.trace("Version slice n. {} wich is '{}' parsed as short {}", i, stringSlices[i], n);
} catch(NumberFormatException nfe){
logger.trace("Version slice n. {} wich is '{}' failed to parse. The default value {} will be used", i, stringSlices[i], versionSlices[i]);
}
}
} catch(Exception e){
logger.trace("Error parsing the supplied version the default will be used", versionSlices);
}
logger.trace("Version {} parsed as {}", version, versionSlices);
return versionSlices;
}
private static String getRunningOn(ContainerConfiguration containerConfiguration){
return String.format("%s:%s", containerConfiguration.hostname(), containerConfiguration.port());
}
/**
* Create the Service Endpoint using information related to discovered
* available plugins and their own discoverd capabilities
* available plugins and their own discovered capabilities
* @return the created {@link ServiceEndpoint}
*/
protected static ServiceEndpoint createServiceEndpoint(){
@ -161,19 +212,22 @@ public class SmartExecutorInitalizator extends ApplicationLifecycleHandler {
Profile profile = serviceEndpoint.newProfile();
profile.category(ctx.configuration().serviceClass());
profile.name(ctx.configuration().name());
profile.version(ctx.configuration().version());
String version = ctx.configuration().version();
profile.version(version);
profile.description(ctx.configuration().description());
String runningOn = getRunningOn(ctx.container().configuration());
Platform platform = profile.newPlatform();
platform.name(runningOn);
ctx.container().configuration().site();
platform.name(ctx.container().configuration().hostname());
short version = 1;
platform.version(version);
short[] versionSlices = getVersionSlice(version, 4);
platform.version(versionSlices[0]);
platform.minorVersion(versionSlices[1]);
platform.buildVersion(versionSlices[2]);
platform.revisionVersion(versionSlices[3]);
Runtime runtime = profile.newRuntime();
runtime.hostedOn(ctx.container().configuration().hostname());
runtime.hostedOn(runningOn);
runtime.status(ctx.configuration().mode().toString());
Group<AccessPoint> accessPoints = profile.accessPoints();
@ -204,7 +258,7 @@ public class SmartExecutorInitalizator extends ApplicationLifecycleHandler {
StringWriter stringWriter = new StringWriter();
Resources.marshal(serviceEndpoint, stringWriter);
logger.debug(String.format("The created ServiceEndpoint profile is \n%s", stringWriter.toString()));
logger.debug("The created ServiceEndpoint profile is\n{}", stringWriter.toString());
return serviceEndpoint;
}
@ -215,9 +269,9 @@ public class SmartExecutorInitalizator extends ApplicationLifecycleHandler {
Set<String> scopes;
if(applicationScopes==null || applicationScopes.isEmpty()){
scopes = containerScopes;
logger.debug(String.format("Application Scopes (%s). The Container Scopes (%s) will be used.", applicationScopes, scopes));
logger.debug("Application Scopes ({}). The Container Scopes ({}) will be used.", applicationScopes, scopes);
} else{
logger.debug(String.format("Container Scopes (%s). Application Scopes (%s) will be used.", containerScopes, applicationScopes));
logger.debug("Container Scopes ({}). Application Scopes ({}) will be used.", containerScopes, applicationScopes);
scopes = new HashSet<String>(applicationScopes);
}
return new ArrayList<String>(scopes);
@ -232,9 +286,10 @@ public class SmartExecutorInitalizator extends ApplicationLifecycleHandler {
*/
@Override
public void onStart(ApplicationLifecycleEvent.Start applicationLifecycleEventStart) {
logger.debug("-------------------------------------------------------");
logger.debug("Smart Executor is Starting");
logger.debug("-------------------------------------------------------");
logger.debug(
"\n-------------------------------------------------------\n"
+ "Smart Executor is Starting\n"
+ "-------------------------------------------------------");
ctx = applicationLifecycleEventStart.context();
@ -243,15 +298,48 @@ public class SmartExecutorInitalizator extends ApplicationLifecycleHandler {
serviceEndpoint = createServiceEndpoint();
pluginInstances = new HashMap<UUID, PluginThread<Plugin<? extends PluginDeclaration>>>();
// TODO Before publishing the new Resource check if on IS there is
// an old published ServiceEndpoint resource that where not unpublished
// correctly
// checking if there are old unpublished ServiceEndpoint related to this ghn
// and try to unpublish them
List<String> scopes = getScopes(ctx);
for(String scope : scopes){
try {
ScopeProvider.instance.set(scope);
SimpleQuery query = ICFactory.queryFor(ServiceEndpoint.class);
query.addCondition(String.format("$resource/Profile/Category/text() eq '%s'", ctx.configuration().serviceClass()));
query.addCondition(String.format("$resource/Profile/Name/text() eq '%s'", ctx.configuration().name()));
query.addCondition(String.format("$resource/Profile/RunTime/HostedOn/text() eq '%s'", getRunningOn(ctx.container().configuration())));
query.setResult("$resource");
DiscoveryClient<ServiceEndpoint> client = ICFactory.clientFor(ServiceEndpoint.class);
List<ServiceEndpoint> serviceEndpoints = client.submit(query);
for (ServiceEndpoint serviceEndpoint : serviceEndpoints) {
try {
logger.debug("Trying to unpublish the old ServiceEndpoint with ID {} from scope {}",
serviceEndpoint.id(), scope);
List<String> undeployScopes = new ArrayList<String>();
undeployScopes.add(scope);
unPublishScopedResource(serviceEndpoint, undeployScopes);
} catch(Exception e){
logger.debug("Exception tryng to unpublish the old ServiceEndpoint with ID {} from scope {}",
serviceEndpoint.id(), scope, e);
}
}
}catch(Exception e){
logger.debug("An Exception occur while checking and/or unpublishing old ServiceEndpoint", e);
}
}
// TODO set task that are still on running state on DB to have a clear
// room
try {
publishScopedResource(serviceEndpoint, getScopes(ctx));
publishScopedResource(serviceEndpoint, scopes);
} catch (RegistryNotFoundException e) {
logger.error("Unable to Create ServiceEndpoint. the Service will be aborted", e);
return;
@ -267,9 +355,10 @@ public class SmartExecutorInitalizator extends ApplicationLifecycleHandler {
return;
}
logger.debug("-------------------------------------------------------");
logger.debug("Smart Executor Started Successfully");
logger.debug("-------------------------------------------------------");
logger.debug(
"\n-------------------------------------------------------\n"
+ "Smart Executor Started Successfully\n"
+ "-------------------------------------------------------");
}
/** {@inheritDoc} */
@ -280,9 +369,10 @@ public class SmartExecutorInitalizator extends ApplicationLifecycleHandler {
*/
@Override
public void onStop(ApplicationLifecycleEvent.Stop applicationLifecycleEventStop) {
logger.debug("-------------------------------------------------------");
logger.debug("Smart Executor is Stopping");
logger.debug("-------------------------------------------------------");
logger.debug(
"\n-------------------------------------------------------\n"
+ "Smart Executor is Stopping\n"
+ "-------------------------------------------------------");
for(UUID uuid : pluginInstances.keySet()){
@ -291,25 +381,21 @@ public class SmartExecutorInitalizator extends ApplicationLifecycleHandler {
Plugin<? extends PluginDeclaration> pluginInstace =
pluginThread.getPlugin();
try {
logger.debug(String.format("Requesting Stop to plugin instance "
+ "identified by the UUID %s of Plugin named %s", uuid,
pluginInstace.getPluginDeclaration().getName()));
logger.debug("Requesting Stop to plugin instance identified by the UUID %s of Plugin named {}",
uuid, pluginInstace.getPluginDeclaration().getName());
pluginInstace.stop();
logger.debug(String.format("Plugin instance identified by the"
+ "UUID %s of Plugin named %s stopped coorectly itself",
uuid, pluginInstace.getPluginDeclaration().getName()));
logger.debug("Plugin instance identified by the UUID {} of Plugin named {} stopped coorectly itself",
uuid, pluginInstace.getPluginDeclaration().getName());
} catch (Exception e) {
logger.debug(String.format("Running plugin instance identified "
+ "by the UUID %s of Plugin named %s failed to request "
+ "of being stopped", uuid,
pluginInstace.getPluginDeclaration().getName()));
logger.debug("Running plugin instance identified by the UUID {} of Plugin named {} failed to request of being stopped",
uuid, pluginInstace.getPluginDeclaration().getName());
} finally {
pluginInstace.setState(PluginState.SUSPENDED);
pluginInstances.remove(uuid);
}
}
// Forcing shutdown of all threads
// Trying to force shutdown of all threads
pool.shutdown();
try {
@ -326,8 +412,10 @@ public class SmartExecutorInitalizator extends ApplicationLifecycleHandler {
logger.error("Unable to close Persistence", e);
}
logger.debug("-------------------------------------------------------");
logger.debug("Smart Executor Stopped Successfully");
logger.debug("-------------------------------------------------------");
logger.debug(
"\n-------------------------------------------------------\n"
+ "Smart Executor Stopped Successfully\n"
+ "-------------------------------------------------------");
}
}