You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@stanbol.apache.org by en...@apache.org on 2011/11/09 13:41:23 UTC
svn commit: r1199715 - in
/incubator/stanbol/branches/lto-reasoners/reasoners: jobs/api/
servicesapi/src/main/java/org/apache/stanbol/reasoners/servicesapi/
web/src/main/java/org/apache/stanbol/reasoners/web/resources/
web/src/main/java/org/apache/stan...
Author: enridaga
Date: Wed Nov 9 12:41:22 2011
New Revision: 1199715
URL: http://svn.apache.org/viewvc?rev=1199715&view=rev
Log:
Main changes have been around the ReasoningServiceExecutor class, in order to prepare it to be an imlementation of Callable to be given to the JobManager.
* Removed references to JAX-RS types from ReasoningServiceExecutor
* Created two new types:
** ReasoningServiceResult, to be processed by the JAX-RS resource. In perspective this would be the outcome of the job (Callable<ReasoningServiceResult>)
** ResponseTaskBuilder, this class compute the JAX-RX response Object with data from a ReasoningServiceBuilder.
These two classes whould be moved to the api, later
STANBOL-343
Added:
incubator/stanbol/branches/lto-reasoners/reasoners/web/src/main/java/org/apache/stanbol/reasoners/web/utils/ReasoningServiceResult.java
incubator/stanbol/branches/lto-reasoners/reasoners/web/src/main/java/org/apache/stanbol/reasoners/web/utils/ResponseTaskBuilder.java
Modified:
incubator/stanbol/branches/lto-reasoners/reasoners/jobs/api/ (props changed)
incubator/stanbol/branches/lto-reasoners/reasoners/servicesapi/src/main/java/org/apache/stanbol/reasoners/servicesapi/ReasoningServiceException.java
incubator/stanbol/branches/lto-reasoners/reasoners/web/src/main/java/org/apache/stanbol/reasoners/web/resources/ReasoningServiceTaskResource.java
incubator/stanbol/branches/lto-reasoners/reasoners/web/src/main/java/org/apache/stanbol/reasoners/web/utils/ReasoningServiceExecutor.java
Propchange: incubator/stanbol/branches/lto-reasoners/reasoners/jobs/api/
------------------------------------------------------------------------------
--- svn:ignore (added)
+++ svn:ignore Wed Nov 9 12:41:22 2011
@@ -0,0 +1,4 @@
+.settings
+target
+.classpath
+.project
Modified: incubator/stanbol/branches/lto-reasoners/reasoners/servicesapi/src/main/java/org/apache/stanbol/reasoners/servicesapi/ReasoningServiceException.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/branches/lto-reasoners/reasoners/servicesapi/src/main/java/org/apache/stanbol/reasoners/servicesapi/ReasoningServiceException.java?rev=1199715&r1=1199714&r2=1199715&view=diff
==============================================================================
--- incubator/stanbol/branches/lto-reasoners/reasoners/servicesapi/src/main/java/org/apache/stanbol/reasoners/servicesapi/ReasoningServiceException.java (original)
+++ incubator/stanbol/branches/lto-reasoners/reasoners/servicesapi/src/main/java/org/apache/stanbol/reasoners/servicesapi/ReasoningServiceException.java Wed Nov 9 12:41:22 2011
@@ -1,7 +1,11 @@
package org.apache.stanbol.reasoners.servicesapi;
public class ReasoningServiceException extends Exception {
-
+ public ReasoningServiceException(Throwable t) {
+ super(t);
+ }
+ public ReasoningServiceException() {
+ }
/**
*
*/
Modified: incubator/stanbol/branches/lto-reasoners/reasoners/web/src/main/java/org/apache/stanbol/reasoners/web/resources/ReasoningServiceTaskResource.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/branches/lto-reasoners/reasoners/web/src/main/java/org/apache/stanbol/reasoners/web/resources/ReasoningServiceTaskResource.java?rev=1199715&r1=1199714&r2=1199715&view=diff
==============================================================================
--- incubator/stanbol/branches/lto-reasoners/reasoners/web/src/main/java/org/apache/stanbol/reasoners/web/resources/ReasoningServiceTaskResource.java (original)
+++ incubator/stanbol/branches/lto-reasoners/reasoners/web/src/main/java/org/apache/stanbol/reasoners/web/resources/ReasoningServiceTaskResource.java Wed Nov 9 12:41:22 2011
@@ -50,10 +50,15 @@ import org.apache.stanbol.ontologymanage
import org.apache.stanbol.owl.transformation.JenaToOwlConvert;
import org.apache.stanbol.reasoners.jena.JenaReasoningService;
import org.apache.stanbol.reasoners.owlapi.OWLApiReasoningService;
+import org.apache.stanbol.reasoners.servicesapi.InconsistentInputException;
import org.apache.stanbol.reasoners.servicesapi.ReasoningService;
+import org.apache.stanbol.reasoners.servicesapi.ReasoningServiceException;
import org.apache.stanbol.reasoners.servicesapi.ReasoningServicesManager;
import org.apache.stanbol.reasoners.servicesapi.UnboundReasoningServiceException;
+import org.apache.stanbol.reasoners.servicesapi.UnsupportedTaskException;
import org.apache.stanbol.reasoners.web.utils.ReasoningServiceExecutor;
+import org.apache.stanbol.reasoners.web.utils.ReasoningServiceResult;
+import org.apache.stanbol.reasoners.web.utils.ResponseTaskBuilder;
import org.apache.stanbol.rules.base.api.NoSuchRecipeException;
import org.apache.stanbol.rules.base.api.Recipe;
import org.apache.stanbol.rules.base.api.RuleStore;
@@ -252,39 +257,47 @@ public class ReasoningServiceTaskResourc
this.parameters.remove("target");
// The service executor
- ReasoningServiceExecutor executor = new ReasoningServiceExecutor(tcManager, headers, servletContext,
- uriInfo);
-
- /**
- * Select the service implementation TODO Question: how this part could be decoupled?
- */
- if (getCurrentService() instanceof JenaReasoningService) {
- // Prepare input data
- Model input;
- try {
- input = prepareJenaInputFromGET(url, scope, session);
- } catch (DoesNotExistException e) {
- throw new WebApplicationException(e, Response.Status.NOT_FOUND);
- }
- // Prepare rules
- // TODO (this is not implemented yet!)
- List<Rule> rules = prepareJenaRules(recipe);
- return executor.executeJenaReasoningService(getCurrentTask(),
- (JenaReasoningService) getCurrentService(), input, rules, targetGraphID, false,
- this.parameters);
- } else if (getCurrentService() instanceof OWLApiReasoningService) {
- OWLOntology input = null;
- try {
- input = prepareOWLApiInputFromGET(url, scope, session);
- } catch (OWLOntologyCreationIOException e) {
- throw new WebApplicationException(e, Response.Status.NOT_FOUND);
- } catch (OWLOntologyCreationException e) {
- throw new WebApplicationException(e, Response.Status.INTERNAL_SERVER_ERROR);
- }
- // Prepare rules
- List<SWRLRule> rules = prepareOWLApiRules(recipe);
- return executor.executeOWLApiReasoningService(getCurrentTask(),
- (OWLApiReasoningService) getCurrentService(), input, rules, targetGraphID, false, this.parameters);
+ ReasoningServiceExecutor executor = new ReasoningServiceExecutor(tcManager);
+ try {
+ /**
+ * Select the service implementation TODO Question: how this part could be decoupled?
+ */
+ if (getCurrentService() instanceof JenaReasoningService) {
+ // Prepare input data
+ Model input;
+ try {
+ input = prepareJenaInputFromGET(url, scope, session);
+ } catch (DoesNotExistException e) {
+ throw new WebApplicationException(e, Response.Status.NOT_FOUND);
+ }
+ // Prepare rules
+ // TODO (this is not implemented yet!)
+ List<Rule> rules = prepareJenaRules(recipe);
+ ReasoningServiceResult<Model> res = executor.executeJenaReasoningService(getCurrentTask(),
+ (JenaReasoningService) getCurrentService(), input, rules, targetGraphID, false,
+ this.parameters);
+ return new ResponseTaskBuilder(uriInfo,context,headers).build(res);
+ } else if (getCurrentService() instanceof OWLApiReasoningService) {
+ OWLOntology input = null;
+ try {
+ input = prepareOWLApiInputFromGET(url, scope, session);
+ } catch (OWLOntologyCreationIOException e) {
+ throw new WebApplicationException(e, Response.Status.NOT_FOUND);
+ } catch (OWLOntologyCreationException e) {
+ throw new WebApplicationException(e, Response.Status.INTERNAL_SERVER_ERROR);
+ }
+ // Prepare rules
+ List<SWRLRule> rules = prepareOWLApiRules(recipe);
+ ReasoningServiceResult<OWLOntology> res = executor.executeOWLApiReasoningService(getCurrentTask(),
+ (OWLApiReasoningService) getCurrentService(), input, rules, targetGraphID, false, this.parameters);
+ return new ResponseTaskBuilder(uriInfo,context,headers).build(res);
+ }
+ } catch (InconsistentInputException e) {
+ new WebApplicationException(e);
+ } catch (ReasoningServiceException e) {
+ new WebApplicationException(e);
+ } catch (UnsupportedTaskException e) {
+ new WebApplicationException(e);
}
throw new WebApplicationException(new Exception("Unsupported implementation"),
Response.Status.INTERNAL_SERVER_ERROR);
@@ -350,38 +363,46 @@ public class ReasoningServiceTaskResourc
log.info("Called {} with parameters: {} ",httpContext.getRequest().getMethod(), parameters.keySet().toArray(new String[parameters.keySet().size()]));
if (file.exists() && file.canRead()) {
// The service executor
- ReasoningServiceExecutor executor = new ReasoningServiceExecutor(tcManager, headers,
- servletContext, uriInfo);
-
- // Select the service implementation
- if (getCurrentService() instanceof JenaReasoningService) {
- // Prepare input data
- Model input;
- try {
- input = prepareJenaInputFromPOST(file, scope, session);
- } catch (MalformedURLException e) {
- throw new WebApplicationException(new IllegalArgumentException("Cannot read file"),
- Response.Status.INTERNAL_SERVER_ERROR);
- }
- // Prepare rules
- List<Rule> rules = prepareJenaRules(recipe);
- return executor.executeJenaReasoningService(getCurrentTask(),
- (JenaReasoningService) getCurrentService(), input, rules, targetGraphID, false,
- this.parameters);
- } else if (getCurrentService() instanceof OWLApiReasoningService) {
- OWLOntology input = null;
- try {
- input = prepareOWLApiInputFromPOST(file, scope, session);
- } catch (OWLOntologyCreationIOException e) {
- throw new WebApplicationException(e, Response.Status.NOT_FOUND);
- } catch (OWLOntologyCreationException e) {
- throw new WebApplicationException(e, Response.Status.INTERNAL_SERVER_ERROR);
+ ReasoningServiceExecutor executor = new ReasoningServiceExecutor(tcManager);
+ try{
+ // Select the service implementation
+ if (getCurrentService() instanceof JenaReasoningService) {
+ // Prepare input data
+ Model input;
+ try {
+ input = prepareJenaInputFromPOST(file, scope, session);
+ } catch (MalformedURLException e) {
+ throw new WebApplicationException(new IllegalArgumentException("Cannot read file"),
+ Response.Status.INTERNAL_SERVER_ERROR);
+ }
+ // Prepare rules
+ List<Rule> rules = prepareJenaRules(recipe);
+ ReasoningServiceResult<Model> result = executor.executeJenaReasoningService(getCurrentTask(),
+ (JenaReasoningService) getCurrentService(), input, rules, targetGraphID, false,
+ this.parameters);
+ return new ResponseTaskBuilder(uriInfo,context,headers).build(result);
+ } else if (getCurrentService() instanceof OWLApiReasoningService) {
+ OWLOntology input = null;
+ try {
+ input = prepareOWLApiInputFromPOST(file, scope, session);
+ } catch (OWLOntologyCreationIOException e) {
+ throw new WebApplicationException(e, Response.Status.NOT_FOUND);
+ } catch (OWLOntologyCreationException e) {
+ throw new WebApplicationException(e, Response.Status.INTERNAL_SERVER_ERROR);
+ }
+ // Prepare rules
+ List<SWRLRule> rules = prepareOWLApiRules(recipe);
+ ReasoningServiceResult<OWLOntology> result = executor.executeOWLApiReasoningService(getCurrentTask(),
+ (OWLApiReasoningService) getCurrentService(), input, rules, targetGraphID, false,
+ this.parameters);
+ return new ResponseTaskBuilder(uriInfo,context,headers).build(result);
}
- // Prepare rules
- List<SWRLRule> rules = prepareOWLApiRules(recipe);
- return executor.executeOWLApiReasoningService(getCurrentTask(),
- (OWLApiReasoningService) getCurrentService(), input, rules, targetGraphID, false,
- this.parameters);
+ } catch (InconsistentInputException e) {
+ new WebApplicationException(e);
+ } catch (ReasoningServiceException e) {
+ new WebApplicationException(e);
+ } catch (UnsupportedTaskException e) {
+ new WebApplicationException(e);
}
throw new WebApplicationException(new Exception("Unsupported implementation"),
Response.Status.INTERNAL_SERVER_ERROR);
@@ -610,7 +631,7 @@ public class ReasoningServiceTaskResourc
OntologySpace sessionSpace = null;
if (sessionID != null) {
IRI sessionIRI = IRI.create(sessionID);
- sessionSpace = scope.getSessionSpace(sessionIRI);
+ sessionSpace = scope.getSessionSpace(sessionIRI.toString());
}
OntologySpace coreSpace = scope.getCoreSpace();
Set<OWLOntology> coreOntologies = coreSpace.getOntologies(true);
Modified: incubator/stanbol/branches/lto-reasoners/reasoners/web/src/main/java/org/apache/stanbol/reasoners/web/utils/ReasoningServiceExecutor.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/branches/lto-reasoners/reasoners/web/src/main/java/org/apache/stanbol/reasoners/web/utils/ReasoningServiceExecutor.java?rev=1199715&r1=1199714&r2=1199715&view=diff
==============================================================================
--- incubator/stanbol/branches/lto-reasoners/reasoners/web/src/main/java/org/apache/stanbol/reasoners/web/utils/ReasoningServiceExecutor.java (original)
+++ incubator/stanbol/branches/lto-reasoners/reasoners/web/src/main/java/org/apache/stanbol/reasoners/web/utils/ReasoningServiceExecutor.java Wed Nov 9 12:41:22 2011
@@ -1,30 +1,16 @@
package org.apache.stanbol.reasoners.web.utils;
-import static javax.ws.rs.core.MediaType.TEXT_HTML;
-
-import java.io.ByteArrayOutputStream;
import java.io.IOException;
-import java.util.Arrays;
-import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.locks.Lock;
-import javax.servlet.ServletContext;
-import javax.ws.rs.WebApplicationException;
-import javax.ws.rs.core.HttpHeaders;
-import javax.ws.rs.core.MediaType;
-import javax.ws.rs.core.Response;
-import javax.ws.rs.core.Response.Status;
-import javax.ws.rs.core.UriInfo;
-
import org.apache.clerezza.rdf.core.MGraph;
import org.apache.clerezza.rdf.core.UriRef;
import org.apache.clerezza.rdf.core.access.LockableMGraph;
import org.apache.clerezza.rdf.core.access.NoSuchEntityException;
import org.apache.clerezza.rdf.core.access.TcManager;
-import org.apache.stanbol.commons.web.base.format.KRFormat;
import org.apache.stanbol.owl.transformation.JenaToClerezzaConverter;
import org.apache.stanbol.owl.transformation.OWLAPIToClerezzaConverter;
import org.apache.stanbol.reasoners.jena.JenaReasoningService;
@@ -32,12 +18,10 @@ import org.apache.stanbol.reasoners.owla
import org.apache.stanbol.reasoners.servicesapi.InconsistentInputException;
import org.apache.stanbol.reasoners.servicesapi.ReasoningServiceException;
import org.apache.stanbol.reasoners.servicesapi.UnsupportedTaskException;
-import org.coode.owlapi.manchesterowlsyntax.ManchesterOWLSyntaxOntologyFormat;
import org.semanticweb.owlapi.model.OWLAxiom;
import org.semanticweb.owlapi.model.OWLOntology;
import org.semanticweb.owlapi.model.OWLOntologyCreationException;
import org.semanticweb.owlapi.model.OWLOntologyManager;
-import org.semanticweb.owlapi.model.OWLOntologyStorageException;
import org.semanticweb.owlapi.model.SWRLRule;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -46,16 +30,12 @@ import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.Statement;
import com.hp.hpl.jena.reasoner.rulesys.Rule;
-import com.sun.jersey.api.view.Viewable;
/**
* TODO Add comment
*/
public class ReasoningServiceExecutor {
private Logger log = LoggerFactory.getLogger(getClass());
- private HttpHeaders headers;
- private ServletContext servletContext;
- private UriInfo uriInfo;
private TcManager tcManager;
// This task is not dinamically provided by the service, since it work on a
@@ -63,11 +43,7 @@ public class ReasoningServiceExecutor {
// (isConsistent())
public static String TASK_CHECK = "check";
- public ReasoningServiceExecutor(TcManager tcManager, HttpHeaders headers,
- ServletContext context, UriInfo uriInfo) {
- this.headers = headers;
- this.servletContext = context;
- this.uriInfo = uriInfo;
+ public ReasoningServiceExecutor(TcManager tcManager) {
this.tcManager = tcManager;
}
@@ -81,11 +57,13 @@ public class ReasoningServiceExecutor {
* @param input
* @param rules
* @return
+ * @throws ReasoningServiceException
+ * @throws UnsupportedTaskException
*/
- public Response executeJenaReasoningService(String task,
+ public ReasoningServiceResult<Model> executeJenaReasoningService(String task,
JenaReasoningService s, Model input, List<Rule> rules,
String targetGraphID, boolean filtered,
- Map<String, List<String>> parameters) {
+ Map<String, List<String>> parameters) throws ReasoningServiceException, UnsupportedTaskException {
long start = System.currentTimeMillis();
log.info("[start] Execution: {}",s);
// Check task: this is managed directly by the endpoint
@@ -95,11 +73,10 @@ public class ReasoningServiceExecutor {
boolean is = s.isConsistent(input);
long end = System.currentTimeMillis();
log.info("[end] In time: {}", (end - start));
- return buildCheckResponse(is);
+ return new ReasoningServiceResult<Model>(ReasoningServiceExecutor.TASK_CHECK,is);
} catch (ReasoningServiceException e) {
log.error("Error thrown: {}", e);
- throw new WebApplicationException(e,
- Response.Status.INTERNAL_SERVER_ERROR);
+ throw e;
}
}
try {
@@ -107,7 +84,7 @@ public class ReasoningServiceExecutor {
parameters);
if (result == null) {
log.error("Result is null");
- throw new WebApplicationException();
+ throw new RuntimeException("Result is null.");
}
Model outputModel = ModelFactory.createDefaultModel();
outputModel.add(result.toArray(new Statement[result.size()]));
@@ -118,33 +95,23 @@ public class ReasoningServiceExecutor {
log.info("Prepare output");
if (targetGraphID == null) {
log.info("Returning {} statements", result.size());
- if (isHTML()) {
- ByteArrayOutputStream out = new ByteArrayOutputStream();
- outputModel.write(out, "TURTLE");
- return Response.ok(
- new Viewable("result",
- new ReasoningPrettyResultResource(
- servletContext, uriInfo, out)),
- TEXT_HTML).build();
- } else {
- return Response.ok(outputModel).build();
- }
+ return new ReasoningServiceResult<Model>(task, true, outputModel);
} else {
save(outputModel, targetGraphID);
- return Response.ok().build();
+ return new ReasoningServiceResult<Model>(task, true);
}
} catch (ReasoningServiceException e) {
log.error("Error thrown: {}", e);
- throw new WebApplicationException(e,
- Response.Status.INTERNAL_SERVER_ERROR);
+ throw e;
} catch (InconsistentInputException e) {
log.debug("The input is not consistent");
- return Response.status(Status.NO_CONTENT).build();
+ return new ReasoningServiceResult<Model>(ReasoningServiceExecutor.TASK_CHECK, false);
} catch (UnsupportedTaskException e) {
log.error("Error thrown: {}", e);
- throw new WebApplicationException(e,
- Response.Status.INTERNAL_SERVER_ERROR);
- }
+ throw e;
+ } catch (IOException e) {
+ throw new ReasoningServiceException(e);
+ }
}
/**
@@ -157,10 +124,13 @@ public class ReasoningServiceExecutor {
* @param targetGraphID
* @param parameters
* @return
+ * @throws InconsistentInputException
+ * @throws ReasoningServiceException
+ * @throws UnsupportedTaskException
*/
- public Response executeOWLApiReasoningService(String task,
+ public ReasoningServiceResult<OWLOntology> executeOWLApiReasoningService(String task,
OWLApiReasoningService s, OWLOntology input, List<SWRLRule> rules,
- String targetGraphID,boolean filtered, Map<String, List<String>> parameters) {
+ String targetGraphID, boolean filtered, Map<String, List<String>> parameters) throws InconsistentInputException, ReasoningServiceException, UnsupportedTaskException {
long start = System.currentTimeMillis();
log.info("[start] Execution: {}",s);
// Check task: this is managed directly by the endpoint
@@ -170,10 +140,9 @@ public class ReasoningServiceExecutor {
boolean is = s.isConsistent(input);
long end = System.currentTimeMillis();
log.info("[end] In time: {}", (end - start));
- return buildCheckResponse(is);
+ return new ReasoningServiceResult<OWLOntology>(ReasoningServiceExecutor.TASK_CHECK, is);
} catch (ReasoningServiceException e) {
- throw new WebApplicationException(e,
- Response.Status.INTERNAL_SERVER_ERROR);
+ throw e;
}
}
// We get the manager from the input ontology
@@ -188,134 +157,52 @@ public class ReasoningServiceExecutor {
log.info("Prepare output: {} axioms",axioms.size());
manager.addAxioms(output,axioms);
if (targetGraphID == null) {
- if (isHTML()) {
- ByteArrayOutputStream out = new ByteArrayOutputStream();
- manager.saveOntology(output,
- new ManchesterOWLSyntaxOntologyFormat(), out);
- return Response.ok(
- new Viewable("result",
- new ReasoningPrettyResultResource(
- servletContext, uriInfo, out)),
- TEXT_HTML).build();
- } else {
- return Response.ok(output).build();
- }
+ return new ReasoningServiceResult<OWLOntology>(task, true, manager.getOntology(output.getOntologyID()));
} else {
save(output, targetGraphID);
- return Response.ok().build();
+ return new ReasoningServiceResult<OWLOntology>(task, true);
}
} catch (InconsistentInputException e) {
log.warn("The input is not consistent");
- return buildCheckResponse(false);
+ throw e;
} catch (ReasoningServiceException e) {
- log.error("Error! \n",e);
- throw new WebApplicationException(e,
- Response.Status.INTERNAL_SERVER_ERROR);
+ throw e;
} catch (OWLOntologyCreationException e) {
log.error("Error! \n",e);
- throw new WebApplicationException(e,
- Response.Status.INTERNAL_SERVER_ERROR);
- } catch (OWLOntologyStorageException e) {
- log.error("Error! \n",e);
- throw new WebApplicationException(e,
- Response.Status.INTERNAL_SERVER_ERROR);
+ throw new ReasoningServiceException(new IOException(e));
} catch (UnsupportedTaskException e) {
log.error("Error! \n",e);
- throw new WebApplicationException(e,
- Response.Status.INTERNAL_SERVER_ERROR);
+ throw e;
}catch(Throwable t){
log.error("Error! \n",t);
- throw new WebApplicationException(t,
- Response.Status.INTERNAL_SERVER_ERROR);
+ throw new ReasoningServiceException(t);
}
}
- /**
- * To build the Response for any CHECK task execution
- *
- * @param isConsistent
- * @return
- */
- public Response buildCheckResponse(boolean isConsistent) {
- if (isHTML()) {
- if (isConsistent) {
- log.debug("The input is consistent");
- return Response.ok(
- new Viewable("result",
- new ReasoningPrettyResultResource(
- servletContext, uriInfo,
- "The input is consistent :)")),
- TEXT_HTML).build();
- } else {
- log.debug("The input is not consistent");
- return Response
- .status(Status.NO_CONTENT)
- .entity(new Viewable("result",
- new ReasoningPrettyResultResource(
- servletContext, uriInfo,
- "The input is NOT consistent :(")))
- .type(TEXT_HTML).build();
- }
- } else {
- if (isConsistent) {
- log.debug("The input is consistent");
- return Response.ok("The input is consistent :)").build();
- } else {
- log.debug("The input is not consistent");
- return Response.status(Status.NO_CONTENT).build();
- }
- }
- }
-
- /**
- * Check if the client needs a serialization of the output or a human
- * readable form (HTML)
- *
- * @param headers
- * @return
- */
- public boolean isHTML() {
- // We only want to state if HTML format is the preferred format
- // requested
- Set<String> htmlformats = new HashSet<String>();
- htmlformats.add(TEXT_HTML);
- Set<String> rdfformats = new HashSet<String>();
- String[] formats = { TEXT_HTML, "text/plain", KRFormat.RDF_XML,
- KRFormat.TURTLE, "text/turtle", "text/n3" };
- rdfformats.addAll(Arrays.asList(formats));
- List<MediaType> mediaTypes = headers.getAcceptableMediaTypes();
- for (MediaType t : mediaTypes) {
- String strty = t.toString();
- log.info("Acceptable is {}", t);
- if (htmlformats.contains(strty)) {
- log.debug("Requested format is HTML {}", t);
- return true;
- } else if (rdfformats.contains(strty)) {
- log.debug("Requested format is RDF {}", t);
- return false;
- }
- }
- // Default behavior? Should never happen!
- return true;
- }
/**
* To save data in the triple store.
*
* @param data
* @param targetGraphID
+ * @throws IOException
*/
- protected void save(Object data, String targetGraphID) {
+ protected void save(Object data, String targetGraphID) throws IOException {
log.info("Attempt saving in target graph {}", targetGraphID);
final long startSave = System.currentTimeMillis();
LockableMGraph mGraph;
UriRef graphUriRef = new UriRef(targetGraphID);
- try {
- // Check whether the graph already exists
- mGraph = tcManager.getMGraph(graphUriRef);
- } catch (NoSuchEntityException e) {
- mGraph = tcManager.createMGraph(graphUriRef);
- }
+
+ // tcManager must be synchronized
+ synchronized (tcManager) {
+ try {
+ // Check whether the graph already exists
+ mGraph = tcManager.getMGraph(graphUriRef);
+ } catch (NoSuchEntityException e) {
+ mGraph = tcManager.createMGraph(graphUriRef);
+ }
+ }
+
// We lock the graph before proceed
Lock writeLock = mGraph.getLock().writeLock();
boolean saved = false;
@@ -326,16 +213,15 @@ public class ReasoningServiceExecutor {
saved = mGraph.addAll(m);
writeLock.unlock();
} else if (data instanceof OWLOntology) {
- MGraph m = OWLAPIToClerezzaConverter
+ MGraph m = (MGraph) OWLAPIToClerezzaConverter
.owlOntologyToClerezzaMGraph((OWLOntology) data);
writeLock.lock();
saved = mGraph.addAll(m);
writeLock.unlock();
}
if (!saved)
- throw new WebApplicationException(new IOException(
- "Cannot save model!"),
- Response.Status.INTERNAL_SERVER_ERROR);
+ throw new IOException(
+ "Cannot save the result in clerezza!");
final long endSave = System.currentTimeMillis();
log.info("Save time: {}", (endSave - startSave));
}
Added: incubator/stanbol/branches/lto-reasoners/reasoners/web/src/main/java/org/apache/stanbol/reasoners/web/utils/ReasoningServiceResult.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/branches/lto-reasoners/reasoners/web/src/main/java/org/apache/stanbol/reasoners/web/utils/ReasoningServiceResult.java?rev=1199715&view=auto
==============================================================================
--- incubator/stanbol/branches/lto-reasoners/reasoners/web/src/main/java/org/apache/stanbol/reasoners/web/utils/ReasoningServiceResult.java (added)
+++ incubator/stanbol/branches/lto-reasoners/reasoners/web/src/main/java/org/apache/stanbol/reasoners/web/utils/ReasoningServiceResult.java Wed Nov 9 12:41:22 2011
@@ -0,0 +1,43 @@
+package org.apache.stanbol.reasoners.web.utils;
+
+public class ReasoningServiceResult<T extends Object> {
+ private T resultObj;
+ private boolean success;
+ private String task;
+
+ public ReasoningServiceResult(String task, boolean success, T resultObj) {
+ this.task = task;
+ this.resultObj = resultObj;
+ this.success = success;
+ }
+
+ public ReasoningServiceResult(String task, boolean success) {
+ this.task = task;
+ this.resultObj = null;
+ this.success = success;
+ }
+
+ public ReasoningServiceResult(String task, T resultObj) {
+ this.task = task;
+ this.resultObj = resultObj;
+ this.success = true;
+ }
+
+ public ReasoningServiceResult(String task) {
+ this.task = task;
+ this.resultObj = null;
+ this.success = true;
+ }
+
+ public Object get() {
+ return this.resultObj;
+ }
+
+ public boolean isSuccess() {
+ return success;
+ }
+
+ public String getTask() {
+ return task;
+ }
+}
Added: incubator/stanbol/branches/lto-reasoners/reasoners/web/src/main/java/org/apache/stanbol/reasoners/web/utils/ResponseTaskBuilder.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/branches/lto-reasoners/reasoners/web/src/main/java/org/apache/stanbol/reasoners/web/utils/ResponseTaskBuilder.java?rev=1199715&view=auto
==============================================================================
--- incubator/stanbol/branches/lto-reasoners/reasoners/web/src/main/java/org/apache/stanbol/reasoners/web/utils/ResponseTaskBuilder.java (added)
+++ incubator/stanbol/branches/lto-reasoners/reasoners/web/src/main/java/org/apache/stanbol/reasoners/web/utils/ResponseTaskBuilder.java Wed Nov 9 12:41:22 2011
@@ -0,0 +1,180 @@
+package org.apache.stanbol.reasoners.web.utils;
+
+import static javax.ws.rs.core.MediaType.TEXT_HTML;
+
+import java.io.ByteArrayOutputStream;
+import java.io.OutputStream;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import javax.servlet.ServletContext;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.UriInfo;
+import javax.ws.rs.core.Response.Status;
+
+import org.apache.stanbol.commons.web.base.format.KRFormat;
+import org.coode.owlapi.manchesterowlsyntax.ManchesterOWLSyntaxOntologyFormat;
+import org.semanticweb.owlapi.io.StreamDocumentTarget;
+import org.semanticweb.owlapi.model.OWLOntology;
+import org.semanticweb.owlapi.model.OWLOntologyStorageException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import uk.ac.manchester.cs.owl.owlapi.mansyntaxrenderer.ManchesterOWLSyntaxOntologyStorer;
+
+import com.hp.hpl.jena.rdf.model.Model;
+import com.sun.jersey.api.view.Viewable;
+
+public class ResponseTaskBuilder {
+ private final Logger log = LoggerFactory.getLogger(getClass());
+ private UriInfo info;
+ private ServletContext context;
+ private HttpHeaders headers;
+
+ public ResponseTaskBuilder(UriInfo info, ServletContext context, HttpHeaders headers) {
+ this.info = info;
+ this.context = context;
+ this.headers = headers;
+ }
+
+ /**
+ * This is special, in case of task CHECK
+ *
+ * @param output
+ * @return
+ */
+ private Response build(boolean result) {
+ return buildCheckResponse(result);
+ }
+
+ private Response build(){
+ return Response.ok().build();
+ }
+
+ private Response build(Object object){
+ if (isHTML()) {
+ OutputStream out = stream(object);
+ return Response.ok(
+ new Viewable("result",
+ new ReasoningPrettyResultResource(
+ context, info, out)),
+ TEXT_HTML).build();
+ } else {
+ return Response.ok(object).build();
+ }
+ }
+
+ /**
+ * FIXME: Both should return the same format
+ *
+ * @param object
+ * @return
+ */
+ private OutputStream stream(Object object) {
+ ByteArrayOutputStream out = new ByteArrayOutputStream();
+ if(object instanceof OWLOntology){
+ OWLOntology o = (OWLOntology) object;
+ ManchesterOWLSyntaxOntologyStorer mosos = new ManchesterOWLSyntaxOntologyStorer();
+ try {
+ mosos.storeOntology(o.getOWLOntologyManager(), o, new StreamDocumentTarget(out), new ManchesterOWLSyntaxOntologyFormat());
+ } catch (OWLOntologyStorageException e) {
+ log.error("Cannot stream the ontology",e);
+ throw new RuntimeException(e);
+ }
+ }else if (object instanceof Model){
+ Model m = (Model) object;
+ // FIXME Both should return the same format
+ m.write(out, "TURTLE");
+ }
+
+ return out;
+ }
+
+ /**
+ * Check if the client needs a serialization of the output or a human
+ * readable form (HTML)
+ *
+ * @param headers
+ * @return
+ */
+ private boolean isHTML() {
+ // We only want to state if HTML format is the preferred format
+ // requested
+ Set<String> htmlformats = new HashSet<String>();
+ htmlformats.add(TEXT_HTML);
+ Set<String> rdfformats = new HashSet<String>();
+ String[] formats = { TEXT_HTML, "text/plain", KRFormat.RDF_XML,
+ KRFormat.TURTLE, "text/turtle", "text/n3" };
+ rdfformats.addAll(Arrays.asList(formats));
+ List<MediaType> mediaTypes = headers.getAcceptableMediaTypes();
+ for (MediaType t : mediaTypes) {
+ String strty = t.toString();
+ log.info("Acceptable is {}", t);
+ if (htmlformats.contains(strty)) {
+ log.debug("Requested format is HTML {}", t);
+ return true;
+ } else if (rdfformats.contains(strty)) {
+ log.debug("Requested format is RDF {}", t);
+ return false;
+ }
+ }
+ // Default behavior? Should never happen!
+ return true;
+ }
+
+
+ /**
+ * To build the Response for any CHECK task execution
+ *
+ * @param isConsistent
+ * @return
+ */
+ private Response buildCheckResponse(boolean isConsistent) {
+ if (isHTML()) {
+ if (isConsistent) {
+ log.debug("The input is consistent");
+ return Response.ok(
+ new Viewable("result",
+ new ReasoningPrettyResultResource(
+ context, info,
+ "The input is consistent :)")),
+ TEXT_HTML).build();
+ } else {
+ log.debug("The input is not consistent");
+ return Response
+ .status(Status.NO_CONTENT)
+ .entity(new Viewable("result",
+ new ReasoningPrettyResultResource(
+ context, info,
+ "The input is NOT consistent :(")))
+ .type(TEXT_HTML).build();
+ }
+ } else {
+ if (isConsistent) {
+ log.debug("The input is consistent");
+ return Response.ok("The input is consistent :)").build();
+ } else {
+ log.debug("The input is not consistent");
+ return Response.status(Status.NO_CONTENT).build();
+ }
+ }
+ }
+
+ public Response build(ReasoningServiceResult<? extends Object> result){
+ // If task is CHECK
+ if(result.getTask().equals(ReasoningServiceExecutor.TASK_CHECK)){
+ return build(result.isSuccess());
+ }else{
+ // Elsewhere, if some data is provided, serialize result
+ if(result.get()!=null){
+ return build(result.get());
+ }else{
+ return build();
+ }
+ }
+ }
+}