litvinovg/vitro
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

VIVO-82 Use ModelAccess to get the OntModelSelectors

Browse source 
Since the OntModelSelectors are facades over the OntModels stored in ModelAccess, remove any attempts to set the OntModelSelectors.
This commit is contained in:
j2blake 2013-05-17 17:14:19 -04:00
parent 1d8da55fdb
commit 864c93432f
22 changed files with 240 additions and 398 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
webapp/src/edu/cornell/mannlib/vedit/controller/BaseEditController.java
View file

@ -27,6 +27,7 @@ import edu.cornell.mannlib.vitro.webapp.controller.VitroHttpServlet;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
public class BaseEditController extends VitroHttpServlet {
@ -167,7 +168,7 @@ public class BaseEditController extends VitroHttpServlet {
}
if ( ontModel == null ) {
ontModel = (OntModel) ModelContext.getBaseOntModelSelector(ctx).getTBoxModel();
ontModel = ModelAccess.on(ctx).getOntModel(ModelID.BASE_TBOX);
}
return ontModel;

5
webapp/src/edu/cornell/mannlib/vitro/webapp/auth/permissions/PermissionSetsLoader.java
View file

@ -32,10 +32,10 @@ import com.hp.hpl.jena.vocabulary.RDFS;
import edu.cornell.mannlib.vitro.webapp.beans.PermissionSet;
import edu.cornell.mannlib.vitro.webapp.beans.UserAccount;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.UserAccountsDao;
import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.startup.StartupStatus;
/**
@ -100,8 +100,7 @@ public class PermissionSetsLoader implements ServletContextListener {
this.ctx = ctx;
this.ss = ss;
this.userAccountsModel = ModelContext.getBaseOntModelSelector(ctx)
.getUserAccountsModel();
this.userAccountsModel = ModelAccess.on(ctx).getUserAccountsModel();
this.permissionSetType = this.userAccountsModel
.getProperty(VitroVocabulary.PERMISSIONSET);

9
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/AbstractPageHandler.java
View file

@ -19,12 +19,12 @@ import com.hp.hpl.jena.ontology.OntModel;
import edu.cornell.mannlib.vitro.webapp.dao.DataPropertyStatementDao;
import edu.cornell.mannlib.vitro.webapp.dao.IndividualDao;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID;
import edu.cornell.mannlib.vitro.webapp.dao.ObjectPropertyStatementDao;
import edu.cornell.mannlib.vitro.webapp.dao.UserAccountsDao;
import edu.cornell.mannlib.vitro.webapp.dao.VClassDao;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.dao.jena.OntModelSelector;
import edu.cornell.mannlib.vitro.webapp.i18n.I18n;
import edu.cornell.mannlib.vitro.webapp.i18n.I18nBundle;
@ -56,9 +56,8 @@ public abstract class AbstractPageHandler {
this.i18n = I18n.bundle(vreq);
this.ctx = vreq.getSession().getServletContext();
OntModelSelector oms = ModelContext.getUnionOntModelSelector(ctx);
userAccountsModel = oms.getUserAccountsModel();
unionModel = oms.getFullModel();
userAccountsModel = ModelAccess.on(ctx).getUserAccountsModel();
unionModel = ModelAccess.on(ctx).getOntModel(ModelID.UNION_FULL);
WebappDaoFactory wdf = (WebappDaoFactory) this.ctx
.getAttribute("webappDaoFactory");

11
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/VitroRequest.java
View file

@ -104,10 +104,6 @@ public class VitroRequest extends HttpServletRequestWrapper {
setAttribute("dataset", dataset);
}
public void setOntModelSelector(OntModelSelector oms) {
setAttribute("ontModelSelector", oms);
}
/** gets assertions + inferences WebappDaoFactory with no filtering **/
public WebappDaoFactory getFullWebappDaoFactory() {
Object webappDaoFactoryAttr = _req.getAttribute("fullWebappDaoFactory");
@ -168,12 +164,7 @@ public class VitroRequest extends HttpServletRequestWrapper {
}
public OntModelSelector getOntModelSelector() {
Object o = this.getAttribute("ontModelSelector");
if (o instanceof OntModelSelector) {
return (OntModelSelector) o;
} else {
return null;
}
return ModelAccess.on(this).getOntModelSelector();
}
public void setJenaOntModel(OntModel ontModel) {

8
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/accounts/manageproxies/ajax/BasicProxiesGetter.java
View file

@ -6,7 +6,6 @@ import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletResponse;
@ -21,9 +20,8 @@ import com.hp.hpl.jena.query.QuerySolution;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.controller.ajax.AbstractAjaxResponder;
import edu.cornell.mannlib.vitro.webapp.controller.freemarker.UrlBuilder;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.dao.jena.OntModelSelector;
import edu.cornell.mannlib.vitro.webapp.utils.SparqlQueryRunner;
import edu.cornell.mannlib.vitro.webapp.utils.SparqlQueryUtils;
import edu.cornell.mannlib.vitro.webapp.web.images.PlaceholderUtil;
@ -60,9 +58,7 @@ public class BasicProxiesGetter extends AbstractAjaxResponder {
super(servlet, vreq, resp);
term = getStringParameter(PARAMETER_SEARCH_TERM, "");
ServletContext ctx = vreq.getSession().getServletContext();
OntModelSelector oms = ModelContext.getUnionOntModelSelector(ctx);
userAccountsModel = oms.getUserAccountsModel();
userAccountsModel = ModelAccess.on(vreq).getUserAccountsModel();
placeholderImageUrl = UrlBuilder.getUrl(PlaceholderUtil
.getPlaceholderImagePathForType(vreq,

35
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/ajax/SparqlQueryAjaxController.java
View file

@ -2,11 +2,9 @@
package edu.cornell.mannlib.vitro.webapp.controller.ajax;
import static javax.servlet.http.HttpServletResponse.SC_INTERNAL_SERVER_ERROR;
import static javax.servlet.http.HttpServletResponse.SC_NOT_FOUND;
import java.io.IOException;
import java.io.OutputStream;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
@ -15,22 +13,14 @@ import javax.servlet.http.HttpServletResponse;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.hp.hpl.jena.query.Dataset;
import com.hp.hpl.jena.query.DatasetFactory;
import com.hp.hpl.jena.query.Query;
import com.hp.hpl.jena.query.QueryExecution;
import com.hp.hpl.jena.query.QueryExecutionFactory;
import com.hp.hpl.jena.query.QueryFactory;
import com.hp.hpl.jena.query.ResultSet;
import com.hp.hpl.jena.query.ResultSetFormatter;
import com.hp.hpl.jena.query.Syntax;
import com.hp.hpl.jena.rdf.model.Model;
import edu.cornell.mannlib.vitro.webapp.auth.permissions.SimplePermission;
import edu.cornell.mannlib.vitro.webapp.auth.requestedAction.Actions;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.controller.ajax.SparqlUtils.AjaxControllerException;
import edu.cornell.mannlib.vitro.webapp.dao.jena.OntModelSelector;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
/**
* Handle an AJAX request for a SPARQL query. On entry, the "query" parameter
@ -86,29 +76,12 @@ public class SparqlQueryAjaxController extends VitroAjaxController {
}
private Model locateModel(VitroRequest vreq, String modelParam)
throws AjaxControllerException {
Object o = getServletContext().getAttribute("baseOntModelSelector");
if (!(o instanceof OntModelSelector)) {
throw new AjaxControllerException(SC_INTERNAL_SERVER_ERROR,
"OntModelSelector not found");
}
OntModelSelector oms = (OntModelSelector) o;
Model model = null;
private Model locateModel(VitroRequest vreq, String modelParam) {
if (OPTION_MODEL_USER_ACCOUNTS.equals(modelParam)) {
model = oms.getUserAccountsModel();
return ModelAccess.on(vreq).getUserAccountsModel();
} else {
// TODO What is the appropriate way to do this?
// model = oms.getFullModel();
model = vreq.getJenaOntModel();
return ModelAccess.on(vreq).getJenaOntModel();
}
if (model == null) {
throw new AjaxControllerException(SC_INTERNAL_SERVER_ERROR,
"Model '' not found.");
}
return model;
}
private String locateQueryParam(VitroRequest vreq)

9
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/edit/RefactorOperationController.java
View file

@ -49,7 +49,7 @@ import edu.cornell.mannlib.vitro.webapp.auth.permissions.SimplePermission;
import edu.cornell.mannlib.vitro.webapp.controller.Controllers;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID;
import edu.cornell.mannlib.vitro.webapp.dao.jena.event.EditEvent;
import edu.cornell.mannlib.vitro.webapp.servlet.setup.FileGraphSetup;
import edu.cornell.mannlib.vitro.webapp.servlet.setup.JenaDataSourceSetupBase;
@ -235,10 +235,10 @@ public class RefactorOperationController extends BaseEditController {
Model model = null;
if (JenaDataSourceSetupBase.JENA_TBOX_ASSERTIONS_MODEL.equals(graphURI)) {
model = ModelContext.getBaseOntModelSelector(getServletContext()).getTBoxModel();
model = ModelAccess.on(getServletContext()).getOntModel(ModelID.BASE_TBOX);
doNotify = true;
} else if (JenaDataSourceSetupBase.JENA_DB_MODEL.equals(graphURI)) {
model = ModelContext.getBaseOntModelSelector(getServletContext()).getABoxModel();
model = ModelAccess.on(getServletContext()).getOntModel(ModelID.BASE_ABOX);
doNotify = true;
} else {
model = dataset.getNamedModel(graphURI);
@ -251,8 +251,7 @@ public class RefactorOperationController extends BaseEditController {
dataset.getLock().leaveCriticalSection();
}
renameResourceInModel(ModelContext.getOntModelSelector(
getServletContext()).getUserAccountsModel(),
renameResourceInModel(ModelAccess.on(getServletContext()).getUserAccountsModel(),
userURI, oldURIStr, newURIStr, !NOTIFY);
// there are no statements to delete, but we want indexes updated appropriately

28
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/jena/JenaExportController.java
View file

@ -5,8 +5,6 @@ package edu.cornell.mannlib.vitro.webapp.controller.jena;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import java.util.HashMap;
import java.util.Map;
@ -30,8 +28,9 @@ import edu.cornell.mannlib.vitro.webapp.auth.permissions.SimplePermission;
import edu.cornell.mannlib.vitro.webapp.auth.requestedAction.Actions;
import edu.cornell.mannlib.vitro.webapp.controller.Controllers;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID;
import edu.cornell.mannlib.vitro.webapp.dao.jena.JenaModelUtils;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.dao.jena.RDFServiceModelMaker;
import edu.cornell.mannlib.vitro.webapp.rdfservice.RDFService;
import edu.cornell.mannlib.vitro.webapp.rdfservice.RDFServiceException;
@ -121,8 +120,7 @@ public class JenaExportController extends BaseEditController {
if( "abox".equals(subgraphParam)){
model = ModelFactory.createDefaultModel();
if("inferred".equals(assertedOrInferredParam)){
model = ModelContext.getInferenceOntModelSelector(
getServletContext()).getABoxModel();
model = ModelAccess.on(getServletContext()).getOntModel(ModelID.INFERRED_ABOX);
}
else if("full".equals(assertedOrInferredParam)){
outputSparqlConstruct(ABOX_FULL_CONSTRUCT, formatParam, response);
@ -137,10 +135,9 @@ public class JenaExportController extends BaseEditController {
// so we'll extract the whole ontology and then include
// only those statements that are in the inferred graph
Model tempModel = xutil.extractTBox(
ModelContext.getUnionOntModelSelector(
getServletContext()).getTBoxModel(), ontologyURI);
Model inferenceModel = ModelContext.getInferenceOntModelSelector(
getServletContext()).getTBoxModel();
ModelAccess.on(getServletContext()).getOntModel(ModelID.UNION_TBOX),
ontologyURI);
Model inferenceModel = ModelAccess.on(getServletContext()).getOntModel(ModelID.INFERRED_TBOX);
inferenceModel.enterCriticalSection(Lock.READ);
try {
model = tempModel.intersection(inferenceModel);
@ -149,12 +146,11 @@ public class JenaExportController extends BaseEditController {
}
} else if ("full".equals(assertedOrInferredParam)) {
model = xutil.extractTBox(
ModelContext.getUnionOntModelSelector(
getServletContext()).getTBoxModel(), ontologyURI);
ModelAccess.on(getServletContext()).getOntModel(ModelID.UNION_TBOX),
ontologyURI);
} else {
model = xutil.extractTBox(
ModelContext.getBaseOntModelSelector(
getServletContext()).getTBoxModel(), ontologyURI);
ModelAccess.on(getServletContext()).getOntModel(ModelID.BASE_TBOX), ontologyURI);
}
}
@ -162,10 +158,8 @@ public class JenaExportController extends BaseEditController {
if("inferred".equals(assertedOrInferredParam)){
ontModel = xutil.extractTBox(
dataset, ontologyURI, INFERENCE_GRAPH);
ontModel.addSubModel(ModelContext.getInferenceOntModelSelector(
getServletContext()).getABoxModel());
ontModel.addSubModel(ModelContext.getInferenceOntModelSelector(
getServletContext()).getTBoxModel());
ontModel.addSubModel(ModelAccess.on(getServletContext()).getOntModel(ModelID.INFERRED_ABOX));
ontModel.addSubModel(ModelAccess.on(getServletContext()).getOntModel(ModelID.INFERRED_TBOX));
}
else if("full".equals(assertedOrInferredParam)){
outputSparqlConstruct(FULL_FULL_CONSTRUCT, formatParam, response);

23
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/jena/JenaIngestController.java
View file

@ -68,8 +68,8 @@ import edu.cornell.mannlib.vitro.webapp.beans.Ontology;
import edu.cornell.mannlib.vitro.webapp.controller.Controllers;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID;
import edu.cornell.mannlib.vitro.webapp.dao.OntologyDao;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.dao.jena.RDFServiceGraph;
import edu.cornell.mannlib.vitro.webapp.dao.jena.RDFServiceModelMaker;
import edu.cornell.mannlib.vitro.webapp.dao.jena.VitroJenaModelMaker;
@ -80,8 +80,8 @@ import edu.cornell.mannlib.vitro.webapp.rdfservice.ChangeSet;
import edu.cornell.mannlib.vitro.webapp.rdfservice.RDFService;
import edu.cornell.mannlib.vitro.webapp.rdfservice.RDFServiceException;
import edu.cornell.mannlib.vitro.webapp.rdfservice.impl.RDFServiceUtils;
import edu.cornell.mannlib.vitro.webapp.servlet.setup.JenaDataSourceSetupBase;
import edu.cornell.mannlib.vitro.webapp.servlet.setup.ContentModelSetup;
import edu.cornell.mannlib.vitro.webapp.servlet.setup.JenaDataSourceSetupBase;
import edu.cornell.mannlib.vitro.webapp.utils.SparqlQueryUtils;
import edu.cornell.mannlib.vitro.webapp.utils.jena.JenaIngestUtils;
import edu.cornell.mannlib.vitro.webapp.utils.jena.JenaIngestUtils.MergeResult;
@ -662,8 +662,7 @@ public class JenaIngestController extends BaseEditController {
* get baseOnt and infOnt models
*/
OntModel baseOntModel = ModelAccess.on(getServletContext()).getBaseOntModel();
OntModel tboxOntModel = ModelContext.getUnionOntModelSelector(
getServletContext()).getTBoxModel();
OntModel tboxOntModel = ModelAccess.on(getServletContext()).getOntModel(ModelID.UNION_TBOX);
/*
* calling method that does the merge operation.
@ -826,10 +825,10 @@ public class JenaIngestController extends BaseEditController {
return;
}
Model m = modelMaker.getModel(modelName);
ModelContext.getBaseOntModelSelector(getServletContext()).getTBoxModel().addSubModel(m);
ModelContext.getBaseOntModelSelector(getServletContext()).getABoxModel().addSubModel(m);
ModelContext.getUnionOntModelSelector(getServletContext()).getABoxModel().addSubModel(m);
ModelContext.getUnionOntModelSelector(getServletContext()).getTBoxModel().addSubModel(m);
ModelAccess.on(getServletContext()).getOntModel(ModelID.BASE_ABOX).addSubModel(m);
ModelAccess.on(getServletContext()).getOntModel(ModelID.BASE_TBOX).addSubModel(m);
ModelAccess.on(getServletContext()).getOntModel(ModelID.UNION_ABOX).addSubModel(m);
ModelAccess.on(getServletContext()).getOntModel(ModelID.UNION_TBOX).addSubModel(m);
attachedModels.put(modelName, m);
log.info("Attached " + modelName + " (" + m.hashCode() + ") to webapp");
}
@ -839,10 +838,10 @@ public class JenaIngestController extends BaseEditController {
if (m == null) {
return;
}
ModelContext.getBaseOntModelSelector(getServletContext()).getTBoxModel().removeSubModel(m);
ModelContext.getBaseOntModelSelector(getServletContext()).getABoxModel().removeSubModel(m);
ModelContext.getUnionOntModelSelector(getServletContext()).getABoxModel().removeSubModel(m);
ModelContext.getUnionOntModelSelector(getServletContext()).getTBoxModel().removeSubModel(m);
ModelAccess.on(getServletContext()).getOntModel(ModelID.BASE_ABOX).removeSubModel(m);
ModelAccess.on(getServletContext()).getOntModel(ModelID.BASE_TBOX).removeSubModel(m);
ModelAccess.on(getServletContext()).getOntModel(ModelID.UNION_ABOX).removeSubModel(m);
ModelAccess.on(getServletContext()).getOntModel(ModelID.UNION_TBOX).removeSubModel(m);
attachedModels.remove(modelName);
log.info("Detached " + modelName + " (" + m.hashCode() + ") from webapp");
}

21
webapp/src/edu/cornell/mannlib/vitro/webapp/controller/jena/RDFUploadController.java
View file

@ -34,7 +34,9 @@ import edu.cornell.mannlib.vedit.beans.LoginStatusBean;
import edu.cornell.mannlib.vitro.webapp.auth.permissions.SimplePermission;
import edu.cornell.mannlib.vitro.webapp.controller.Controllers;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID;
import edu.cornell.mannlib.vitro.webapp.dao.jena.JenaModelUtils;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.dao.jena.OntModelSelector;
@ -170,14 +172,12 @@ public class RDFUploadController extends JenaIngestController {
JenaModelUtils xutil = new JenaModelUtils();
OntModel tboxModel = getTBoxModel(
request.getSession(), getServletContext());
OntModel tboxModel = getTBoxModel(request.getSession());
OntModel aboxModel = getABoxModel(
request.getSession(), getServletContext());
OntModel tboxChangeModel = null;
Model aboxChangeModel = null;
OntModelSelector ontModelSelector = ModelContext.getOntModelSelector(
getServletContext());
OntModelSelector ontModelSelector = ModelAccess.on(getServletContext()).getOntModelSelector();
if (tboxModel != null) {
boolean AGGRESSIVE = true;
@ -428,17 +428,8 @@ public class RDFUploadController extends JenaIngestController {
return ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM, abox);
}
private OntModel getTBoxModel(HttpSession session, ServletContext ctx) {
if (session != null
&& session.getAttribute("baseOntModelSelector")
instanceof OntModelSelector) {
return ((OntModelSelector)
session.getAttribute("baseOntModelSelector"))
.getTBoxModel();
} else {
return ((OntModelSelector)
ctx.getAttribute("baseOntModelSelector")).getTBoxModel();
}
private OntModel getTBoxModel(HttpSession session) {
return ModelAccess.on(session).getOntModel(ModelID.BASE_TBOX);
}
private static final Log log = LogFactory.getLog(

260
webapp/src/edu/cornell/mannlib/vitro/webapp/dao/ModelAccess.java
View file

@ -9,12 +9,19 @@ import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import com.hp.hpl.jena.ontology.OntModel;
import edu.cornell.mannlib.vitro.webapp.dao.jena.OntModelSelector;
/**
* Hierarchical storage for models. TODO
*/
public class ModelAccess {
private static final Log log = LogFactory.getLog(ModelAccess.class);
/** These attributes should only be accessed through this class. */
private static final String ATTRIBUTE_NAME = ModelAccess.class.getName();
@ -32,6 +39,10 @@ public class ModelAccess {
UNION_ABOX, UNION_TBOX, UNION_FULL
}
private enum Scope {
CONTEXT, SESSION, REQUEST
}
// ----------------------------------------------------------------------
// Factory methods
// ----------------------------------------------------------------------
@ -42,7 +53,7 @@ public class ModelAccess {
return (ModelAccess) o;
} else {
ModelAccess parent = on(req.getSession());
ModelAccess ma = new ModelAccess(parent);
ModelAccess ma = new ModelAccess(Scope.REQUEST, parent);
req.setAttribute(ATTRIBUTE_NAME, ma);
return ma;
}
@ -54,7 +65,7 @@ public class ModelAccess {
return (ModelAccess) o;
} else {
ModelAccess parent = on(session.getServletContext());
ModelAccess ma = new ModelAccess(parent);
ModelAccess ma = new ModelAccess(Scope.SESSION, parent);
session.setAttribute(ATTRIBUTE_NAME, ma);
return ma;
}
@ -65,23 +76,33 @@ public class ModelAccess {
if (o instanceof ModelAccess) {
return (ModelAccess) o;
} else {
ModelAccess ma = new ModelAccess(null);
ModelAccess ma = new ModelAccess(Scope.CONTEXT, null);
ctx.setAttribute(ATTRIBUTE_NAME, ma);
return ma;
}
}
// ----------------------------------------------------------------------
// Instance methods
// The instance
// ----------------------------------------------------------------------
private final Scope scope;
private final ModelAccess parent;
private final Map<String, OntModel> modelMap = new HashMap<>();
public ModelAccess(ModelAccess parent) {
public ModelAccess(Scope scope, ModelAccess parent) {
this.scope = scope;
this.parent = parent;
}
// ----------------------------------------------------------------------
// Accessing the models
// ----------------------------------------------------------------------
public OntModel getApplicationMetadataModel() {
return getOntModel(ModelID.APPLICATION_METADATA);
}
public void setUserAccountsModel(OntModel m) {
setOntModel(ModelID.USER_ACCOUNTS, m);
}
@ -118,6 +139,105 @@ public class ModelAccess {
return getOntModel(ModelID.INFERRED_FULL);
}
public void setOntModel(ModelID id, OntModel ontModel) {
String key = id.toString();
if (ontModel == null) {
modelMap.remove(key);
} else {
modelMap.put(key, ontModel);
}
}
public OntModel getOntModel(ModelID id) {
String key = id.toString();
if (modelMap.containsKey(key)) {
log.debug("Using " + id + " model from " + scope);
return modelMap.get(key);
} else if (parent != null) {
return parent.getOntModel(id);
} else {
log.warn("No model found for " + id);
return null;
}
}
// ----------------------------------------------------------------------
// Accessing the OntModelSelectors
// ----------------------------------------------------------------------
public OntModelSelector getOntModelSelector() {
return getUnionOntModelSelector();
}
public OntModelSelector getBaseOntModelSelector() {
return new FacadeOntModelSelector(this, ModelID.BASE_ABOX,
ModelID.BASE_TBOX, ModelID.BASE_FULL);
}
public OntModelSelector getInferenceOntModelSelector() {
return new FacadeOntModelSelector(this, ModelID.INFERRED_ABOX,
ModelID.INFERRED_TBOX, ModelID.INFERRED_FULL);
}
public OntModelSelector getUnionOntModelSelector() {
return new FacadeOntModelSelector(this, ModelID.UNION_ABOX,
ModelID.UNION_TBOX, ModelID.UNION_FULL);
}
// ----------------------------------------------------------------------
// Helper classes
// ----------------------------------------------------------------------
private static class FacadeOntModelSelector implements OntModelSelector {
private final ModelAccess parent;
private final ModelID aboxID;
private final ModelID tboxID;
private final ModelID fullID;
public FacadeOntModelSelector(ModelAccess parent, ModelID aboxID,
ModelID tboxID, ModelID fullID) {
this.parent = parent;
this.aboxID = aboxID;
this.tboxID = tboxID;
this.fullID = fullID;
}
@Override
public OntModel getABoxModel() {
return parent.getOntModel(aboxID);
}
@Override
public OntModel getTBoxModel() {
return parent.getOntModel(tboxID);
}
@Override
public OntModel getTBoxModel(String ontologyURI) {
return parent.getOntModel(tboxID);
}
@Override
public OntModel getFullModel() {
return parent.getOntModel(fullID);
}
@Override
public OntModel getApplicationMetadataModel() {
return parent.getOntModel(ModelID.APPLICATION_METADATA);
}
@Override
public OntModel getUserAccountsModel() {
return parent.getOntModel(ModelID.USER_ACCOUNTS);
}
@Override
public OntModel getDisplayModel() {
return parent.getOntModel(ModelID.DISPLAY);
}
}
// public OntModel getDisplayTboxOntModel() {
// throw new RuntimeException(
// "ModelAccess.getDisplayTboxOntModel not implemented.");
@ -128,113 +248,7 @@ public class ModelAccess {
// "ModelAccess.getDisplayModelDisplayOntModel not implemented.");
// }
//
// public OntModelSelector getOntModelSelector() {
// return getUnionOntModelSelector();
// }
//
// public OntModelSelector getBaseOntModelSelector() {
// return new FacadeOntModelSelector(this, ModelID.BASE_ABOX,
// ModelID.BASE_TBOX, ModelID.BASE_FULL);
// }
//
// public OntModelSelector getInferenceOntModelSelector() {
// return new FacadeOntModelSelector(this, ModelID.INFERRED_ABOX,
// ModelID.INFERRED_TBOX, ModelID.INFERRED_FULL);
// }
//
// public OntModelSelector getUnionOntModelSelector() {
// return new FacadeOntModelSelector(this, ModelID.UNION_ABOX,
// ModelID.UNION_TBOX, ModelID.UNION_FULL);
// }
//
// private static class FacadeOntModelSelector implements OntModelSelector {
// private final ModelAccess parent;
// private final ModelID aboxID;
// private final ModelID tboxID;
// private final ModelID fullID;
//
// public FacadeOntModelSelector(ModelAccess parent, ModelID aboxID,
// ModelID tboxID, ModelID fullID) {
// this.parent = parent;
// this.aboxID = aboxID;
// this.tboxID = tboxID;
// this.fullID = fullID;
// }
//
// @Override
// public OntModel getABoxModel() {
// return parent.getOntModel(aboxID);
// }
//
// @Override
// public OntModel getTBoxModel() {
// return parent.getOntModel(tboxID);
// }
//
// @Override
// public OntModel getTBoxModel(String ontologyURI) {
// return parent.getOntModel(tboxID);
// }
//
// @Override
// public OntModel getFullModel() {
// return parent.getOntModel(fullID);
// }
//
// @Override
// public OntModel getApplicationMetadataModel() {
// return parent.getOntModel(ModelID.APPLICATION_METADATA);
// }
//
// @Override
// public OntModel getUserAccountsModel() {
// return parent.getOntModel(ModelID.USER_ACCOUNTS);
// }
//
// @Override
// public OntModel getDisplayModel() {
// return parent.getOntModel(ModelID.DISPLAY);
// }
// }
/**
* <pre>
* From ModelContext
*
* public static OntModelSelector getOntModelSelector(ServletContext ctx) {
* return (OntModelSelector) ctx.getAttribute(ONT_MODEL_SELECTOR);
* }
*
* public static void setOntModelSelector(OntModelSelector oms, ServletContext ctx) {
* ctx.setAttribute(ONT_MODEL_SELECTOR, oms);
* }
*
* public static OntModelSelector getUnionOntModelSelector(ServletContext ctx) {
* return (OntModelSelector) ctx.getAttribute(UNION_ONT_MODEL_SELECTOR);
* }
*
* public static void setUnionOntModelSelector(OntModelSelector oms, ServletContext ctx) {
* ctx.setAttribute(UNION_ONT_MODEL_SELECTOR, oms);
* }
*
* public static OntModelSelector getBaseOntModelSelector(ServletContext ctx) {
* return (OntModelSelector) ctx.getAttribute(BASE_ONT_MODEL_SELECTOR);
* }
*
* public static void setBaseOntModelSelector(OntModelSelector oms, ServletContext ctx) {
* ctx.setAttribute(BASE_ONT_MODEL_SELECTOR, oms);
* }
*
* public static OntModelSelector getInferenceOntModelSelector(ServletContext ctx) {
* return (OntModelSelector) ctx.getAttribute(INFERENCE_ONT_MODEL_SELECTOR);
* }
*
* public static void setInferenceOntModelSelector(OntModelSelector oms, ServletContext ctx) {
* ctx.setAttribute(INFERENCE_ONT_MODEL_SELECTOR, oms);
* }
*
* </pre>
*/
/**
* <pre>
* VitroRequest.getAssertionsWebappDaoFactory()
@ -246,10 +260,6 @@ public class ModelAccess {
* VitroRequest.getWriteModel()
* VitroRequest.getJenaOntModel()
* VitroRequest.setJenaOntModel()
* ModelContext.getBaseOntModelSelector()
* ModelContext.getInferenceOntModelSelector()
* ModelContext.getOntModelSelector()
* ModelContext.getUnionOntModelSelector()
* OntModelSelector.getAboxModel
* OntModelSelector.getApplicationMetadataModel()
* OntModelSelector.getFullModel()
@ -273,24 +283,4 @@ public class ModelAccess {
* </pre>
*/
public void setOntModel(ModelID id, OntModel ontModel) {
String key = id.toString();
if (ontModel == null) {
modelMap.remove(key);
} else {
modelMap.put(key, ontModel);
}
}
public OntModel getOntModel(ModelID id) {
String key = id.toString();
if (modelMap.containsKey(key)) {
return modelMap.get(key);
} else if (parent != null) {
return parent.getOntModel(id);
} else {
return null;
}
}
}

40
webapp/src/edu/cornell/mannlib/vitro/webapp/dao/jena/ModelContext.java
View file

@ -13,48 +13,8 @@ import edu.cornell.mannlib.vitro.webapp.rdfservice.RDFServiceException;
import edu.cornell.mannlib.vitro.webapp.rdfservice.impl.RDFServiceUtils;
public class ModelContext {
private static final Log log = LogFactory.getLog(ModelContext.class);
private static final String ONT_MODEL_SELECTOR = "ontModelSelector";
private static final String UNION_ONT_MODEL_SELECTOR = "unionOntModelSelector";
private static final String BASE_ONT_MODEL_SELECTOR = "baseOntModelSelector";
private static final String INFERENCE_ONT_MODEL_SELECTOR = "inferenceOntModelSelector";
public ModelContext() {}
public static OntModelSelector getOntModelSelector(ServletContext ctx) {
return (OntModelSelector) ctx.getAttribute(ONT_MODEL_SELECTOR);
}
public static void setOntModelSelector(OntModelSelector oms, ServletContext ctx) {
ctx.setAttribute(ONT_MODEL_SELECTOR, oms);
}
public static OntModelSelector getUnionOntModelSelector(ServletContext ctx) {
return (OntModelSelector) ctx.getAttribute(UNION_ONT_MODEL_SELECTOR);
}
public static void setUnionOntModelSelector(OntModelSelector oms, ServletContext ctx) {
ctx.setAttribute(UNION_ONT_MODEL_SELECTOR, oms);
}
public static OntModelSelector getBaseOntModelSelector(ServletContext ctx) {
return (OntModelSelector) ctx.getAttribute(BASE_ONT_MODEL_SELECTOR);
}
public static void setBaseOntModelSelector(OntModelSelector oms, ServletContext ctx) {
ctx.setAttribute(BASE_ONT_MODEL_SELECTOR, oms);
}
public static OntModelSelector getInferenceOntModelSelector(ServletContext ctx) {
return (OntModelSelector) ctx.getAttribute(INFERENCE_ONT_MODEL_SELECTOR);
}
public static void setInferenceOntModelSelector(OntModelSelector oms, ServletContext ctx) {
ctx.setAttribute(INFERENCE_ONT_MODEL_SELECTOR, oms);
}
/**
* Register a listener to the models needed to get changes to:
* Basic abox statemetns:

26
webapp/src/edu/cornell/mannlib/vitro/webapp/edit/n3editing/configuration/StandardModelSelector.java
View file

@ -10,35 +10,15 @@ import org.apache.commons.logging.LogFactory;
import com.hp.hpl.jena.ontology.OntModel;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.dao.jena.OntModelSelector;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID;
public class StandardModelSelector implements ModelSelector {
private static final Log log = LogFactory.getLog(StandardModelSelector.class);
public OntModel getModel(HttpServletRequest request, ServletContext context) {
VitroRequest vreq = new VitroRequest( request );
Object sessionOntModel = null;
if( vreq.getSession() != null) {
OntModelSelector oms = (OntModelSelector) vreq.getSession()
.getAttribute("unionOntModelSelector");
if (oms != null) {
sessionOntModel = oms.getABoxModel();
}
}
if(sessionOntModel != null && sessionOntModel instanceof OntModel ) {
log.debug("using OntModelSelector from session");
return (OntModel)sessionOntModel;
} else if (vreq.getOntModelSelector() != null) {
log.debug("using OntModelSelector from request");
return vreq.getOntModelSelector().getABoxModel();
} else {
log.debug("using OntModelSelector from context");
return ((OntModelSelector) context
.getAttribute("unionOntModelSelector")).getABoxModel();
}
return ModelAccess.on(request.getSession()).getOntModel(ModelID.UNION_ABOX);
}
public static final ModelSelector selector = new StandardModelSelector();

5
webapp/src/edu/cornell/mannlib/vitro/webapp/filters/VitroRequestPrep.java
View file

@ -41,13 +41,11 @@ import edu.cornell.mannlib.vitro.webapp.config.ConfigurationProperties;
import edu.cornell.mannlib.vitro.webapp.controller.VitroHttpServlet;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.dao.filtering.WebappDaoFactoryFiltering;
import edu.cornell.mannlib.vitro.webapp.dao.filtering.filters.FilterFactory;
import edu.cornell.mannlib.vitro.webapp.dao.filtering.filters.HideFromDisplayByPolicyFilter;
import edu.cornell.mannlib.vitro.webapp.dao.filtering.filters.VitroFilters;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.dao.jena.VitroModelSource;
import edu.cornell.mannlib.vitro.webapp.dao.jena.WebappDaoFactoryJena;
import edu.cornell.mannlib.vitro.webapp.dao.jena.WebappDaoFactorySDB;
@ -176,8 +174,7 @@ public class VitroRequestPrep implements Filter {
if (vreq.getUnfilteredWebappDaoFactory() == null) {
vreq.setUnfilteredWebappDaoFactory(new WebappDaoFactorySDB(
RDFServiceUtils.getRDFServiceFactory(ctx).getRDFService(),
ModelContext.getUnionOntModelSelector(
ctx)));
ModelAccess.on(ctx).getUnionOntModelSelector()));
}
req.setAttribute("VitroRequestPrep.setup", new Integer(1));

24
webapp/src/edu/cornell/mannlib/vitro/webapp/filters/WebappDaoFactorySDBPrep.java
View file

@ -26,6 +26,7 @@ import com.hp.hpl.jena.rdf.model.ModelFactory;
import edu.cornell.mannlib.vitro.webapp.config.ConfigurationProperties;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactoryConfig;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
@ -82,8 +83,6 @@ public class WebappDaoFactorySDBPrep implements Filter {
}
}
OntModelSelector oms = ModelContext.getUnionOntModelSelector(_ctx);
OntModelSelector baseOms = ModelContext.getBaseOntModelSelector(_ctx);
String defaultNamespace = (String) _ctx.getAttribute("defaultNamespace");
WebappDaoFactory wadf = null;
VitroRequest vreq = new VitroRequest((HttpServletRequest) request);
@ -104,29 +103,34 @@ public class WebappDaoFactorySDBPrep implements Filter {
if (Boolean.valueOf(ConfigurationProperties.getBean(vreq).getProperty(
"RDFService.languageFilter", "true"))) {
rdfService = new LanguageFilteringRDFService(unfilteredRDFService, langs);
oms = LanguageFilteringUtils.replaceDisplayModelInSelector(oms,
LanguageFilteringUtils.wrapOntModelInALanguageFilter(oms.getDisplayModel(), request));
baseOms = LanguageFilteringUtils.replaceDisplayModelInSelector(baseOms, oms.getDisplayModel());
OntModel rawDisplayModel = ModelAccess.on(vreq.getSession()).getDisplayModel();
OntModel filteredDisplayModel = LanguageFilteringUtils.wrapOntModelInALanguageFilter(rawDisplayModel, request);
ModelAccess.on(vreq).setDisplayModel(filteredDisplayModel);
} else {
rdfService = unfilteredRDFService;
}
Dataset dataset = new RDFServiceDataset(rdfService);
OntModelSelector oms = ModelAccess.on(_ctx).getUnionOntModelSelector();
wadf = new WebappDaoFactorySDB(rdfService, oms, config);
WebappDaoFactory assertions = new WebappDaoFactorySDB(
OntModelSelector baseOms = ModelAccess.on(_ctx).getBaseOntModelSelector();
WebappDaoFactory assertions = new WebappDaoFactorySDB(
rdfService, baseOms, config, SDBDatasetMode.ASSERTIONS_ONLY);
vreq.setRDFService(rdfService);
vreq.setUnfilteredRDFService(unfilteredRDFService);
vreq.setWebappDaoFactory(wadf);
vreq.setAssertionsWebappDaoFactory(assertions);
vreq.setFullWebappDaoFactory(wadf);
vreq.setUnfilteredWebappDaoFactory(new WebappDaoFactorySDB(
rdfService, ModelContext.getUnionOntModelSelector(_ctx)));
rdfService, ModelAccess.on(_ctx).getUnionOntModelSelector()));
vreq.setDataset(dataset);
vreq.setOntModelSelector(baseOms);
vreq.setJenaOntModel(ModelFactory.createOntologyModel(
OntModelSpec.OWL_MEM, dataset.getDefaultModel()));
ModelAccess.on(vreq).setJenaOntModel(
ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM, dataset.getDefaultModel()));
request.setAttribute("WebappDaoFactorySDBPrep.setup", 1);

16
webapp/src/edu/cornell/mannlib/vitro/webapp/filters/WebappDaoFactorySparqlPrep.java
View file

@ -27,7 +27,6 @@ import org.apache.commons.logging.LogFactory;
import com.hp.hpl.jena.graph.Graph;
import com.hp.hpl.jena.ontology.OntModel;
import com.hp.hpl.jena.ontology.OntModelSpec;
import com.hp.hpl.jena.query.DataSource;
import com.hp.hpl.jena.query.Dataset;
import com.hp.hpl.jena.query.DatasetFactory;
import com.hp.hpl.jena.rdf.model.Model;
@ -39,10 +38,11 @@ import com.hp.hpl.jena.sdb.sql.SDBConnection;
import edu.cornell.mannlib.vitro.webapp.config.ConfigurationProperties;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactoryConfig;
import edu.cornell.mannlib.vitro.webapp.dao.jena.OntModelSelector;
import edu.cornell.mannlib.vitro.webapp.dao.jena.SingleContentOntModelSelector;
import edu.cornell.mannlib.vitro.webapp.dao.jena.SparqlDatasetGraph;
import edu.cornell.mannlib.vitro.webapp.dao.jena.SparqlGraphMultilingual;
import edu.cornell.mannlib.vitro.webapp.dao.jena.WebappDaoFactoryJena;
@ -93,7 +93,6 @@ public class WebappDaoFactorySparqlPrep implements Filter {
javax.sql.DataSource ds = JenaDataSourceSetupBase.getApplicationDataSource(_ctx);
StoreDesc storeDesc = (StoreDesc) _ctx.getAttribute("storeDesc");
OntModelSelector oms = (OntModelSelector) _ctx.getAttribute("unionOntModelSelector");
String defaultNamespace = (String) _ctx.getAttribute("defaultNamespace");
Connection sqlConn = null;
SDBConnection conn = null;
@ -102,7 +101,7 @@ public class WebappDaoFactorySparqlPrep implements Filter {
WebappDaoFactory wadf = null;
try {
if (ds == null || storeDesc == null || oms == null) {
if (ds == null || storeDesc == null) {
throw new RuntimeException("SDB store not property set up");
}
@ -147,7 +146,6 @@ public class WebappDaoFactorySparqlPrep implements Filter {
Model m = ModelFactory.createModelForGraph(g);
OntModel om = ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM, m);
oms = new SingleContentOntModelSelector(om, oms.getDisplayModel(), oms.getUserAccountsModel());
dataset = DatasetFactory.create(new SparqlDatasetGraph(endpointURI));
@ -157,15 +155,17 @@ public class WebappDaoFactorySparqlPrep implements Filter {
vreq.setAssertionsWebappDaoFactory(wadf);
ModelAccess.on(vreq).setOntModel(ModelID.UNION_ABOX, om);
ModelAccess.on(vreq).setOntModel(ModelID.UNION_TBOX, om);
ModelAccess.on(vreq).setOntModel(ModelID.UNION_FULL, om);
OntModelSelector oms = ModelAccess.on(vreq).getOntModelSelector();
wadf = new WebappDaoFactoryJena(oms, config);
//wadf = new WebappDaoFactorySDB(oms, dataset, config);
vreq.setWebappDaoFactory(wadf);
vreq.setFullWebappDaoFactory(wadf);
vreq.setUnfilteredWebappDaoFactory(wadf);
vreq.setWebappDaoFactory(wadf);
vreq.setDataset(dataset);
vreq.setJenaOntModel(om);
vreq.setOntModelSelector(oms);
}
} catch (Throwable t) {
log.error("Unable to filter request to set up SDB connection", t);

61
webapp/src/edu/cornell/mannlib/vitro/webapp/servlet/setup/ContentModelSetup.java
View file

@ -31,9 +31,8 @@ import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactoryConfig;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelSynchronizer;
import edu.cornell.mannlib.vitro.webapp.dao.jena.OntModelSelectorImpl;
import edu.cornell.mannlib.vitro.webapp.dao.jena.OntModelSelector;
import edu.cornell.mannlib.vitro.webapp.dao.jena.RDFServiceDataset;
import edu.cornell.mannlib.vitro.webapp.dao.jena.SpecialBulkUpdateHandlerGraph;
import edu.cornell.mannlib.vitro.webapp.dao.jena.WebappDaoFactorySDB;
@ -72,8 +71,7 @@ public class ContentModelSetup extends JenaDataSourceSetupBase
JenaDataSourceSetupBase.thisIsFirstStartup();
}
OntModel userAccountsModel = ModelAccess.on(ctx).getUserAccountsModel();
OntModel displayModel = ModelAccess.on(ctx).getDisplayModel();
ModelAccess models = ModelAccess.on(ctx);
OntModel baseABoxModel = createNamedModelFromDataset(dataset, JENA_DB_MODEL);
OntModel inferenceABoxModel = createNamedModelFromDataset(dataset, JENA_INF_MODEL);
OntModel baseTBoxModel = createdMemoryMappedModel(dataset, JENA_TBOX_ASSERTIONS_MODEL, "tbox assertions");
@ -91,61 +89,34 @@ public class ContentModelSetup extends JenaDataSourceSetupBase
OntModel inferenceFullModel = createCombinedModel(inferenceABoxModel, inferenceTBoxModel);
OntModel unionFullModel = ModelFactory.createOntologyModel(DB_ONT_MODEL_SPEC, dataset.getDefaultModel());
ModelAccess.on(ctx).setOntModel(ModelID.APPLICATION_METADATA, applicationMetadataModel);
ModelAccess.on(ctx).setOntModel(ModelID.USER_ACCOUNTS, userAccountsModel);
ModelAccess.on(ctx).setOntModel(ModelID.DISPLAY, displayModel);
ModelAccess.on(ctx).setOntModel(ModelID.BASE_ABOX, baseABoxModel);
ModelAccess.on(ctx).setOntModel(ModelID.BASE_TBOX, baseTBoxModel);
ModelAccess.on(ctx).setOntModel(ModelID.BASE_FULL, baseFullModel);
ModelAccess.on(ctx).setOntModel(ModelID.INFERRED_ABOX, inferenceABoxModel);
ModelAccess.on(ctx).setOntModel(ModelID.INFERRED_TBOX, inferenceTBoxModel);
ModelAccess.on(ctx).setOntModel(ModelID.INFERRED_FULL, inferenceFullModel);
ModelAccess.on(ctx).setOntModel(ModelID.UNION_ABOX, unionABoxModel);
ModelAccess.on(ctx).setOntModel(ModelID.UNION_TBOX, unionTBoxModel);
ModelAccess.on(ctx).setOntModel(ModelID.UNION_FULL, unionFullModel);
models.setOntModel(ModelID.APPLICATION_METADATA, applicationMetadataModel);
models.setOntModel(ModelID.BASE_ABOX, baseABoxModel);
models.setOntModel(ModelID.BASE_TBOX, baseTBoxModel);
models.setOntModel(ModelID.BASE_FULL, baseFullModel);
models.setOntModel(ModelID.INFERRED_ABOX, inferenceABoxModel);
models.setOntModel(ModelID.INFERRED_TBOX, inferenceTBoxModel);
models.setOntModel(ModelID.INFERRED_FULL, inferenceFullModel);
models.setOntModel(ModelID.UNION_ABOX, unionABoxModel);
models.setOntModel(ModelID.UNION_TBOX, unionTBoxModel);
models.setOntModel(ModelID.UNION_FULL, unionFullModel);
checkForNamespaceMismatch( applicationMetadataModel, ctx );
OntModelSelectorImpl baseOms = new OntModelSelectorImpl();
baseOms.setApplicationMetadataModel(applicationMetadataModel);
baseOms.setUserAccountsModel(userAccountsModel);
baseOms.setDisplayModel(displayModel);
baseOms.setABoxModel(baseABoxModel);
baseOms.setTBoxModel(baseTBoxModel);
baseOms.setFullModel(baseFullModel);
OntModelSelectorImpl inferenceOms = new OntModelSelectorImpl();
inferenceOms.setApplicationMetadataModel(applicationMetadataModel);
inferenceOms.setUserAccountsModel(userAccountsModel);
inferenceOms.setDisplayModel(displayModel);
inferenceOms.setABoxModel(inferenceABoxModel);
inferenceOms.setTBoxModel(inferenceTBoxModel);
inferenceOms.setFullModel(inferenceFullModel);
OntModelSelectorImpl unionOms = new OntModelSelectorImpl();
unionOms.setApplicationMetadataModel(applicationMetadataModel);
unionOms.setUserAccountsModel(userAccountsModel);
unionOms.setDisplayModel(displayModel);
unionOms.setABoxModel(unionABoxModel);
unionOms.setTBoxModel(unionTBoxModel);
unionOms.setFullModel(unionFullModel);
ModelContext.setOntModelSelector(unionOms, ctx);
ModelContext.setUnionOntModelSelector(unionOms, ctx); // assertions and inferences
ModelContext.setBaseOntModelSelector(baseOms, ctx); // assertions
ModelContext.setInferenceOntModelSelector(inferenceOms, ctx); // inferences
log.info("Setting up DAO factories");
WebappDaoFactoryConfig config = new WebappDaoFactoryConfig();
config.setDefaultNamespace(getDefaultNamespace(ctx));
OntModelSelector baseOms = models.getBaseOntModelSelector();
WebappDaoFactory baseWadf = new WebappDaoFactorySDB(rdfService, baseOms, config, ASSERTIONS_ONLY);
ctx.setAttribute("assertionsWebappDaoFactory",baseWadf);
OntModelSelector inferenceOms = models.getInferenceOntModelSelector();
WebappDaoFactory infWadf = new WebappDaoFactorySDB(rdfService, inferenceOms, config, INFERENCES_ONLY);
ctx.setAttribute("deductionsWebappDaoFactory", infWadf);
OntModelSelector unionOms = models.getUnionOntModelSelector();
WebappDaoFactory wadf = new WebappDaoFactorySDB(rdfService, unionOms, config);
ctx.setAttribute("webappDaoFactory",wadf);

14
webapp/src/edu/cornell/mannlib/vitro/webapp/servlet/setup/FileGraphSetup.java
View file

@ -26,7 +26,7 @@ import com.hp.hpl.jena.query.Dataset;
import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.jena.OntModelSelector;
import edu.cornell.mannlib.vitro.webapp.dao.jena.RDFServiceModelMaker;
import edu.cornell.mannlib.vitro.webapp.rdfservice.impl.RDFServiceUtils;
@ -48,16 +48,16 @@ public class FileGraphSetup implements ServletContextListener {
boolean tboxChanged = false; // indicates whether any TBox file graph model has changed
OntModelSelector baseOms = null;
try {
ServletContext ctx = sce.getServletContext();
ServletContext ctx = sce.getServletContext();
try {
OntDocumentManager.getInstance().setProcessImports(true);
baseOms = ModelContext.getBaseOntModelSelector(sce.getServletContext());
Dataset dataset = JenaDataSourceSetupBase.getStartupDataset(sce.getServletContext());
baseOms = ModelAccess.on(ctx).getBaseOntModelSelector();
Dataset dataset = JenaDataSourceSetupBase.getStartupDataset(ctx);
RDFServiceModelMaker maker = new RDFServiceModelMaker(RDFServiceUtils.getRDFServiceFactory(ctx));
// ABox files
Set<String> pathSet = sce.getServletContext().getResourcePaths(PATH_ROOT + ABOX);
Set<String> pathSet = ctx.getResourcePaths(PATH_ROOT + ABOX);
cleanupDB(dataset, pathToURI(pathSet, ABOX), ABOX);
@ -67,7 +67,7 @@ public class FileGraphSetup implements ServletContextListener {
}
// TBox files
pathSet = sce.getServletContext().getResourcePaths(PATH_ROOT + TBOX);
pathSet = ctx.getResourcePaths(PATH_ROOT + TBOX);
cleanupDB(dataset, pathToURI(pathSet, TBOX),TBOX);

12
webapp/src/edu/cornell/mannlib/vitro/webapp/servlet/setup/SimpleReasonerSetup.java
View file

@ -22,7 +22,7 @@ import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.vocabulary.OWL;
import edu.cornell.mannlib.vitro.webapp.config.ConfigurationProperties;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.jena.OntModelSelector;
import edu.cornell.mannlib.vitro.webapp.dao.jena.RDFServiceDataset;
import edu.cornell.mannlib.vitro.webapp.dao.jena.WebappDaoFactoryJena;
@ -33,7 +33,6 @@ import edu.cornell.mannlib.vitro.webapp.rdfservice.impl.RDFServiceUtils;
import edu.cornell.mannlib.vitro.webapp.reasoner.ReasonerPlugin;
import edu.cornell.mannlib.vitro.webapp.reasoner.SimpleReasoner;
import edu.cornell.mannlib.vitro.webapp.reasoner.SimpleReasonerTBoxListener;
import edu.cornell.mannlib.vitro.webapp.servlet.setup.JenaDataSourceSetupBase.TripleStoreType;
import edu.cornell.mannlib.vitro.webapp.startup.StartupStatus;
public class SimpleReasonerSetup implements ServletContextListener {
@ -48,13 +47,13 @@ public class SimpleReasonerSetup implements ServletContextListener {
@Override
public void contextInitialized(ServletContextEvent sce) {
ServletContext ctx = sce.getServletContext();
try {
// set up Pellet reasoning for the TBox
OntModelSelector assertionsOms = ModelContext.getBaseOntModelSelector(sce.getServletContext());
OntModelSelector inferencesOms = ModelContext.getInferenceOntModelSelector(sce.getServletContext());
OntModelSelector unionOms = ModelContext.getUnionOntModelSelector(sce.getServletContext());
OntModelSelector assertionsOms = ModelAccess.on(ctx).getBaseOntModelSelector();
OntModelSelector inferencesOms = ModelAccess.on(ctx).getInferenceOntModelSelector();
OntModelSelector unionOms = ModelAccess.on(ctx).getUnionOntModelSelector();
WebappDaoFactoryJena wadf = (WebappDaoFactoryJena) sce.getServletContext().getAttribute("webappDaoFactory");
@ -83,7 +82,6 @@ public class SimpleReasonerSetup implements ServletContextListener {
// set up simple reasoning for the ABox
ServletContext ctx = sce.getServletContext();
DataSource bds = JenaDataSourceSetupBase
.getApplicationDataSource(ctx);
String dbType = ConfigurationProperties.getBean(ctx).getProperty( // database type

5
webapp/src/edu/cornell/mannlib/vitro/webapp/servlet/setup/ThemeInfoSetup.java
View file

@ -23,7 +23,9 @@ import com.hp.hpl.jena.util.iterator.ClosableIterator;
import edu.cornell.mannlib.vitro.webapp.beans.ApplicationBean;
import edu.cornell.mannlib.vitro.webapp.beans.ApplicationBean.ThemeInfo;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.VitroVocabulary;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.startup.StartupStatus;
@ -91,8 +93,7 @@ public class ThemeInfoSetup implements ServletContextListener {
}
private String getCurrentThemeName(ServletContext ctx) {
OntModel ontModel = ModelContext.getBaseOntModelSelector(ctx)
.getApplicationMetadataModel();
OntModel ontModel = ModelAccess.on(ctx).getApplicationMetadataModel();
ontModel.enterCriticalSection(Lock.READ);
try {

7
webapp/src/edu/cornell/mannlib/vitro/webapp/servlet/setup/UpdateKnowledgeBase.java
View file

@ -34,7 +34,6 @@ import com.hp.hpl.jena.vocabulary.RDFS;
import edu.cornell.mannlib.vitro.webapp.dao.DisplayVocabulary;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.WebappDaoFactory;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.ontology.update.KnowledgeBaseUpdater;
import edu.cornell.mannlib.vitro.webapp.ontology.update.UpdateSettings;
@ -102,9 +101,9 @@ public class UpdateKnowledgeBase implements ServletContextListener {
settings.setRemovedDataFile(ctx.getRealPath(REMOVED_DATA_FILE));
WebappDaoFactory wadf = (WebappDaoFactory) ctx.getAttribute("webappDaoFactory");
settings.setDefaultNamespace(wadf.getDefaultNamespace());
settings.setAssertionOntModelSelector(ModelContext.getBaseOntModelSelector(ctx));
settings.setInferenceOntModelSelector(ModelContext.getInferenceOntModelSelector(ctx));
settings.setUnionOntModelSelector(ModelContext.getUnionOntModelSelector(ctx));
settings.setAssertionOntModelSelector(ModelAccess.on(ctx).getBaseOntModelSelector());
settings.setInferenceOntModelSelector(ModelAccess.on(ctx).getInferenceOntModelSelector());
settings.setUnionOntModelSelector(ModelAccess.on(ctx).getUnionOntModelSelector());
boolean tryMigrateDisplay = true;
try {
settings.setDisplayModel(ModelAccess.on(ctx).getDisplayModel());

4
webapp/src/edu/cornell/mannlib/vitro/webapp/utils/ApplicationConfigurationOntologyUtils.java
View file

@ -24,7 +24,7 @@ import com.hp.hpl.jena.rdf.model.Resource;
import edu.cornell.mannlib.vitro.webapp.beans.ObjectProperty;
import edu.cornell.mannlib.vitro.webapp.controller.VitroRequest;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess;
import edu.cornell.mannlib.vitro.webapp.dao.jena.ModelContext;
import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID;
public class ApplicationConfigurationOntologyUtils {
@ -33,7 +33,7 @@ public class ApplicationConfigurationOntologyUtils {
public static List<ObjectProperty> getAdditionalFauxSubpropertiesForList(List<ObjectProperty> propList, VitroRequest vreq) {
ServletContext ctx = vreq.getSession().getServletContext();
Model displayModel = ModelAccess.on(ctx).getDisplayModel();
Model tboxModel = ModelContext.getUnionOntModelSelector(ctx).getTBoxModel();
Model tboxModel = ModelAccess.on(ctx).getOntModel(ModelID.UNION_TBOX);
return getAdditionalFauxSubpropertiesForList(propList, displayModel, tboxModel);
}