diff --git a/webapp/src/edu/cornell/mannlib/vitro/webapp/controller/jena/JenaIngestController.java b/webapp/src/edu/cornell/mannlib/vitro/webapp/controller/jena/JenaIngestController.java index 16a06008c..b2535cde2 100644 --- a/webapp/src/edu/cornell/mannlib/vitro/webapp/controller/jena/JenaIngestController.java +++ b/webapp/src/edu/cornell/mannlib/vitro/webapp/controller/jena/JenaIngestController.java @@ -1228,17 +1228,9 @@ public class JenaIngestController extends BaseEditController { } - public static Model getModel(String name, HttpServletRequest request) { - if ("vitro:jenaOntModel".equals(name)) { - return ModelAccess.on(request.getSession()).getJenaOntModel(); - } else if ("vitro:baseOntModel".equals(name)) { - return ModelAccess.on(request.getSession()).getBaseOntModel(); - } else if ("vitro:inferenceOntModel".equals(name)) { - return ModelAccess.on(request.getSession()).getInferenceOntModel(); - } else { - return getVitroJenaModelMaker(request).getModel(name); - } - } + public static Model getModel(String name, HttpServletRequest request) { + return getVitroJenaModelMaker(request).getModel(name); + } protected static ModelMaker getVitroJenaModelMaker(HttpServletRequest req){ ServletContext ctx = req.getSession().getServletContext(); diff --git a/webapp/src/edu/cornell/mannlib/vitro/webapp/dao/jena/VitroInterceptingModelMaker.java b/webapp/src/edu/cornell/mannlib/vitro/webapp/dao/jena/VitroInterceptingModelMaker.java new file mode 100644 index 000000000..5ecbc1bf4 --- /dev/null +++ b/webapp/src/edu/cornell/mannlib/vitro/webapp/dao/jena/VitroInterceptingModelMaker.java @@ -0,0 +1,214 @@ +/* $This file is distributed under the terms of the license in /doc/license.txt$ */ + +package edu.cornell.mannlib.vitro.webapp.dao.jena; + +import static edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID.*; +import static edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID.DISPLAY; +import static edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID.INFERRED_FULL; +import static edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID.UNION_FULL; +import static edu.cornell.mannlib.vitro.webapp.servlet.setup.JenaDataSourceSetupBase.*; + +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.Map; +import java.util.Set; + +import javax.servlet.ServletContext; + +import com.hp.hpl.jena.graph.GraphMaker; +import com.hp.hpl.jena.rdf.model.Model; +import com.hp.hpl.jena.rdf.model.ModelMaker; +import com.hp.hpl.jena.rdf.model.ModelReader; +import com.hp.hpl.jena.shared.AlreadyExistsException; +import com.hp.hpl.jena.util.iterator.ExtendedIterator; +import com.hp.hpl.jena.util.iterator.NiceIterator; + +import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess; +import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess.ModelID; +import edu.cornell.mannlib.vitro.webapp.servlet.setup.JenaDataSourceSetupBase; + +/** + * A decorator on top of a model maker. It looks for requests on particular + * URIs, and shunts them to the pre-made models on ModelAccess. + * + * The result is two-fold: + * + * We have effective URIs for models that only exist as combinations of other + * named models (UNION_FULL, BASE_FULL, INFERRED_FULL). + * + * For models with in-memory mapping, a request will return a reference to that + * mapping. + */ +public class VitroInterceptingModelMaker implements ModelMaker { + private final ModelMaker innerMM; + private final ServletContext ctx; + private final Map specialMap; + + public VitroInterceptingModelMaker(ModelMaker innerMM, ServletContext ctx) { + this.innerMM = innerMM; + this.ctx = ctx; + this.specialMap = populateSpecialMap(); + } + + @Override + public Model getModel(String url) { + return isSpecial(url) ? getSpecial(url) : innerMM.getModel(url); + } + + @Override + public Model getModel(String url, ModelReader loadIfAbsent) { + return isSpecial(url) ? getSpecial(url) : innerMM.getModel(url, + loadIfAbsent); + } + + @Override + public Model createDefaultModel() { + return innerMM.createDefaultModel(); + } + + @Override + public Model createFreshModel() { + return innerMM.createFreshModel(); + } + + @Override + public Model openModel(String name) { + return isSpecial(name) ? getSpecial(name) : innerMM.openModel(name); + } + + @Override + public Model openModelIfPresent(String name) { + return isSpecial(name) ? getSpecial(name) : innerMM + .openModelIfPresent(name); + } + + @Override + public void close() { + innerMM.close(); + } + + @Override + public Model createModel(String name) { + return isSpecial(name) ? getSpecial(name) : innerMM.createModel(name); + } + + @Override + public Model createModel(String name, boolean strict) { + if (isSpecial(name)) { + if (strict) { + throw new AlreadyExistsException(name); + } else { + return getSpecial(name); + } + } else { + return innerMM.createModel(name, strict); + } + } + + /** + * TODO this should actually return an intercepting graph maker. + */ + @Override + public GraphMaker getGraphMaker() { + return innerMM.getGraphMaker(); + } + + @Override + public boolean hasModel(String name) { + return isSpecial(name) || innerMM.hasModel(name); + } + + @Override + public ExtendedIterator listModels() { + return new SetsExtendedIterator(getSpecialNames(), innerMM.listModels() + .toSet()); + } + + @Override + public Model openModel(String name, boolean strict) { + return isSpecial(name) ? getSpecial(name) : innerMM.openModel(name, + strict); + } + + /** + * We don't lete anyone remove the special models. + */ + @Override + public void removeModel(String name) { + if (!isSpecial(name)) { + innerMM.removeModel(name); + } + } + + // ---------------------------------------------------------------------- + // Intercepting mechanism + // ---------------------------------------------------------------------- + + private Map populateSpecialMap() { + Map map = new HashMap<>(); + + map.put("vitro:jenaOntModel", + ModelAccess.on(ctx).getOntModel(UNION_FULL)); + map.put("vitro:baseOntModel", ModelAccess.on(ctx) + .getOntModel(BASE_FULL)); + map.put("vitro:inferenceOntModel", + ModelAccess.on(ctx).getOntModel(INFERRED_FULL)); + map.put(JENA_DISPLAY_METADATA_MODEL, + ModelAccess.on(ctx).getOntModel(DISPLAY)); + map.put(JENA_DISPLAY_TBOX_MODEL, + ModelAccess.on(ctx).getOntModel(DISPLAY_TBOX)); + map.put(JENA_DISPLAY_DISPLAY_MODEL, + ModelAccess.on(ctx).getOntModel(DISPLAY_DISPLAY)); + map.put(JENA_USER_ACCOUNTS_MODEL, + ModelAccess.on(ctx).getOntModel(USER_ACCOUNTS)); + map.put(JENA_TBOX_ASSERTIONS_MODEL, + ModelAccess.on(ctx).getOntModel(BASE_TBOX)); + map.put(JENA_TBOX_INF_MODEL, + ModelAccess.on(ctx).getOntModel(INFERRED_TBOX)); + map.put(JENA_APPLICATION_METADATA_MODEL, + ModelAccess.on(ctx).getOntModel(APPLICATION_METADATA)); + map.put(, + ModelAccess.on(ctx).getOntModel()); + + return Collections.unmodifiableMap(map); + } + + private Collection getSpecialNames() { + return specialMap.keySet(); + } + + private boolean isSpecial(String url) { + return specialMap.containsKey(url); + } + + private Model getSpecial(String url) { + return specialMap.get(url); + } + + private static class SetsExtendedIterator extends NiceIterator { + private final Iterator iter; + + @SafeVarargs + public SetsExtendedIterator(Collection... collections) { + Set set = new HashSet<>(); + for (Collection c : collections) { + set.addAll(c); + } + this.iter = set.iterator(); + } + + @Override + public boolean hasNext() { + return iter.hasNext(); + } + + @Override + public String next() { + return iter.next(); + } + + } +} diff --git a/webapp/src/edu/cornell/mannlib/vitro/webapp/servlet/setup/JenaDataSourceSetupBase.java b/webapp/src/edu/cornell/mannlib/vitro/webapp/servlet/setup/JenaDataSourceSetupBase.java index a0efbf141..58ff6a92d 100644 --- a/webapp/src/edu/cornell/mannlib/vitro/webapp/servlet/setup/JenaDataSourceSetupBase.java +++ b/webapp/src/edu/cornell/mannlib/vitro/webapp/servlet/setup/JenaDataSourceSetupBase.java @@ -117,13 +117,13 @@ public class JenaDataSourceSetupBase extends JenaBaseDaoCon { // This is Brian C's application.owl file. We may not have to be concerned // with this for release 1.2. - static final String JENA_DISPLAY_METADATA_MODEL = + public static final String JENA_DISPLAY_METADATA_MODEL = "http://vitro.mannlib.cornell.edu/default/vitro-kb-displayMetadata"; //TBox and display model related - static final String JENA_DISPLAY_TBOX_MODEL = + public static final String JENA_DISPLAY_TBOX_MODEL = DisplayVocabulary.DISPLAY_TBOX_MODEL_URI; - static final String JENA_DISPLAY_DISPLAY_MODEL = + public static final String JENA_DISPLAY_DISPLAY_MODEL = DisplayVocabulary.DISPLAY_DISPLAY_MODEL_URI; // use OWL models with no reasoning diff --git a/webapp/src/edu/cornell/mannlib/vitro/webapp/servlet/setup/ModelMakerSetup.java b/webapp/src/edu/cornell/mannlib/vitro/webapp/servlet/setup/ModelMakerSetup.java index 7c9f107bd..2960cdab8 100644 --- a/webapp/src/edu/cornell/mannlib/vitro/webapp/servlet/setup/ModelMakerSetup.java +++ b/webapp/src/edu/cornell/mannlib/vitro/webapp/servlet/setup/ModelMakerSetup.java @@ -14,6 +14,7 @@ import org.apache.commons.logging.LogFactory; import edu.cornell.mannlib.vitro.webapp.config.ConfigurationProperties; import edu.cornell.mannlib.vitro.webapp.dao.ModelAccess; import edu.cornell.mannlib.vitro.webapp.dao.jena.RDFServiceModelMaker; +import edu.cornell.mannlib.vitro.webapp.dao.jena.VitroInterceptingModelMaker; import edu.cornell.mannlib.vitro.webapp.dao.jena.VitroJenaModelMaker; import edu.cornell.mannlib.vitro.webapp.rdfservice.RDFServiceFactory; import edu.cornell.mannlib.vitro.webapp.rdfservice.impl.RDFServiceUtils; @@ -47,14 +48,18 @@ public class ModelMakerSetup extends JenaDataSourceSetupBase implements "VitroConnection.DataSource.password"); VitroJenaModelMaker vjmm = new VitroJenaModelMaker(jdbcUrl, username, password, dbtypeStr, ctx); - ModelAccess.on(ctx).setModelMaker(CONFIGURATION, vjmm); + VitroInterceptingModelMaker vimm = new VitroInterceptingModelMaker( + vjmm, ctx); + ModelAccess.on(ctx).setModelMaker(CONFIGURATION, vimm); } private void createContentModelMaker(ServletContext ctx) { RDFServiceFactory rdfServiceFactory = RDFServiceUtils .getRDFServiceFactory(ctx); RDFServiceModelMaker vsmm = new RDFServiceModelMaker(rdfServiceFactory); - ModelAccess.on(ctx).setModelMaker(CONTENT, vsmm); + VitroInterceptingModelMaker vimm = new VitroInterceptingModelMaker( + vsmm, ctx); + ModelAccess.on(ctx).setModelMaker(CONTENT, vimm); } @Override