| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.stanbol.ontologymanager.multiplexer.clerezza.collector; |
| |
| import static org.apache.stanbol.ontologymanager.servicesapi.Vocabulary.APPENDED_TO_URIREF; |
| import static org.apache.stanbol.ontologymanager.servicesapi.Vocabulary.DEPENDS_ON_URIREF; |
| import static org.apache.stanbol.ontologymanager.servicesapi.Vocabulary.ENTRY_URIREF; |
| import static org.apache.stanbol.ontologymanager.servicesapi.Vocabulary.HAS_APPENDED_URIREF; |
| import static org.apache.stanbol.ontologymanager.servicesapi.Vocabulary.HAS_DEPENDENT_URIREF; |
| import static org.apache.stanbol.ontologymanager.servicesapi.Vocabulary.HAS_ONTOLOGY_IRI_URIREF; |
| import static org.apache.stanbol.ontologymanager.servicesapi.Vocabulary.HAS_SPACE_CORE_URIREF; |
| import static org.apache.stanbol.ontologymanager.servicesapi.Vocabulary.HAS_SPACE_CUSTOM_URIREF; |
| import static org.apache.stanbol.ontologymanager.servicesapi.Vocabulary.HAS_VERSION_IRI_URIREF; |
| import static org.apache.stanbol.ontologymanager.servicesapi.Vocabulary.IS_MANAGED_BY_URIREF; |
| import static org.apache.stanbol.ontologymanager.servicesapi.Vocabulary.IS_SPACE_CORE_OF_URIREF; |
| import static org.apache.stanbol.ontologymanager.servicesapi.Vocabulary.IS_SPACE_CUSTOM_OF_URIREF; |
| import static org.apache.stanbol.ontologymanager.servicesapi.Vocabulary.MANAGES_URIREF; |
| import static org.apache.stanbol.ontologymanager.servicesapi.Vocabulary.SCOPE_URIREF; |
| import static org.apache.stanbol.ontologymanager.servicesapi.Vocabulary.SESSION_URIREF; |
| import static org.apache.stanbol.ontologymanager.servicesapi.Vocabulary.SIZE_IN_TRIPLES_URIREF; |
| import static org.apache.stanbol.ontologymanager.servicesapi.Vocabulary.SPACE_URIREF; |
| import static org.apache.stanbol.ontologymanager.servicesapi.Vocabulary._NS_STANBOL_INTERNAL; |
| |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.Set; |
| |
| import org.apache.clerezza.commons.rdf.Literal; |
| import org.apache.clerezza.commons.rdf.Graph; |
| import org.apache.clerezza.commons.rdf.BlankNodeOrIRI; |
| import org.apache.clerezza.commons.rdf.RDFTerm; |
| import org.apache.clerezza.commons.rdf.Triple; |
| import org.apache.clerezza.commons.rdf.IRI; |
| import org.apache.clerezza.commons.rdf.impl.utils.TripleImpl; |
| import org.apache.clerezza.rdf.core.LiteralFactory; |
| import org.apache.clerezza.rdf.ontologies.OWL; |
| import org.apache.clerezza.rdf.ontologies.RDF; |
| import org.apache.stanbol.ontologymanager.core.scope.ScopeManagerImpl; |
| import org.apache.stanbol.ontologymanager.multiplexer.clerezza.session.SessionManagerImpl; |
| import org.apache.stanbol.ontologymanager.servicesapi.collector.OntologyCollector; |
| import org.apache.stanbol.ontologymanager.servicesapi.ontology.Multiplexer; |
| import org.apache.stanbol.ontologymanager.servicesapi.scope.OntologySpace; |
| import org.apache.stanbol.ontologymanager.servicesapi.scope.OntologySpace.SpaceType; |
| import org.apache.stanbol.ontologymanager.servicesapi.scope.Scope; |
| import org.apache.stanbol.ontologymanager.servicesapi.scope.ScopeManager; |
| import org.apache.stanbol.ontologymanager.servicesapi.session.Session; |
| import org.apache.stanbol.ontologymanager.servicesapi.session.SessionEvent; |
| import org.apache.stanbol.ontologymanager.servicesapi.session.SessionManager; |
| import org.apache.stanbol.ontologymanager.servicesapi.util.OntologyUtils; |
| import org.semanticweb.owlapi.model.OWLOntologyID; |
| import org.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| /** |
| * TODO make this object update its sizes as a graph changes. |
| * |
| * @author alexdma |
| * |
| */ |
| public class GraphMultiplexer implements Multiplexer { |
| |
| private class InvalidMetaGraphStateException extends RuntimeException { |
| |
| /** |
| * |
| */ |
| private static final long serialVersionUID = 3915817349833358738L; |
| |
| @SuppressWarnings("unused") |
| InvalidMetaGraphStateException() { |
| super(); |
| } |
| |
| InvalidMetaGraphStateException(String message) { |
| super(message); |
| } |
| |
| } |
| |
| private Logger log = LoggerFactory.getLogger(getClass()); |
| |
| private Graph meta; |
| |
| public GraphMultiplexer(Graph metaGraph) { |
| this.meta = metaGraph; |
| } |
| |
| /** |
| * Creates an {@link OWLOntologyID} object by combining the ontologyIRI and the versionIRI, where |
| * applicable, of the stored graph. |
| * |
| * @param resource |
| * the ontology |
| * @return |
| */ |
| protected OWLOntologyID buildPublicKey(final IRI resource) { |
| // TODO desanitize? |
| org.semanticweb.owlapi.model.IRI oiri = null, viri = null; |
| Iterator<Triple> it = meta.filter(resource, HAS_ONTOLOGY_IRI_URIREF, null); |
| if (it.hasNext()) { |
| RDFTerm obj = it.next().getObject(); |
| if (obj instanceof IRI) oiri = org.semanticweb.owlapi.model.IRI.create(((IRI) obj).getUnicodeString()); |
| else if (obj instanceof Literal) oiri = org.semanticweb.owlapi.model.IRI.create(((Literal) obj).getLexicalForm()); |
| } else { |
| // Anonymous ontology? Decode the resource itself (which is not null) |
| return OntologyUtils.decode(resource.getUnicodeString()); |
| } |
| it = meta.filter(resource, HAS_VERSION_IRI_URIREF, null); |
| if (it.hasNext()) { |
| RDFTerm obj = it.next().getObject(); |
| if (obj instanceof IRI) viri = org.semanticweb.owlapi.model.IRI.create(((IRI) obj).getUnicodeString()); |
| else if (obj instanceof Literal) viri = org.semanticweb.owlapi.model.IRI.create(((Literal) obj).getLexicalForm()); |
| } |
| if (viri == null) return new OWLOntologyID(oiri); |
| else return new OWLOntologyID(oiri, viri); |
| } |
| |
| /** |
| * Creates an {@link IRI} out of an {@link OWLOntologyID}, so it can be used as an identifier. This |
| * does NOT necessarily correspond to the IRI that identifies the stored graph. In order to obtain |
| * that, check the objects of any MAPS_TO_GRAPH assertions. |
| * |
| * @param publicKey |
| * @return |
| */ |
| protected IRI buildResource(final OWLOntologyID publicKey) { |
| if (publicKey == null) throw new IllegalArgumentException( |
| "Cannot build a IRI resource on a null public key!"); |
| // The IRI is of the form ontologyIRI[:::versionIRI] (TODO use something less conventional?) |
| // XXX should versionIRI also include the version IRI set by owners? Currently not |
| |
| // Remember not to sanitize logical identifiers. |
| org.semanticweb.owlapi.model.IRI ontologyIri = publicKey.getOntologyIRI(), versionIri = publicKey.getVersionIRI(); |
| if (ontologyIri == null) throw new IllegalArgumentException( |
| "Cannot build a IRI resource on an anonymous public key!"); |
| log.debug("Searching for a meta graph entry for public key:"); |
| log.debug(" -- {}", publicKey); |
| IRI match = null; |
| LiteralFactory lf = LiteralFactory.getInstance(); |
| Literal oiri = lf.createTypedLiteral(new IRI(ontologyIri.toString())); |
| Literal viri = versionIri == null ? null : lf.createTypedLiteral(new IRI(versionIri |
| .toString())); |
| for (Iterator<Triple> it = meta.filter(null, HAS_ONTOLOGY_IRI_URIREF, oiri); it.hasNext();) { |
| RDFTerm subj = it.next().getSubject(); |
| log.debug(" -- Ontology IRI match found. Scanning"); |
| log.debug(" -- RDFTerm : {}", subj); |
| if (!(subj instanceof IRI)) { |
| log.debug(" ---- (uncomparable: skipping...)"); |
| continue; |
| } |
| if (viri != null) { |
| // Must find matching versionIRI |
| if (meta.contains(new TripleImpl((IRI) subj, HAS_VERSION_IRI_URIREF, viri))) { |
| log.debug(" ---- Version IRI match!"); |
| match = (IRI) subj; |
| break; // Found |
| } else { |
| log.debug(" ---- Expected version IRI match not found."); |
| continue; // There could be another with the right versionIRI. |
| } |
| |
| } else { |
| // Must find unversioned resource |
| if (meta.filter((IRI) subj, HAS_VERSION_IRI_URIREF, null).hasNext()) { |
| log.debug(" ---- Unexpected version IRI found. Skipping."); |
| continue; |
| } else { |
| log.debug(" ---- Unversioned match!"); |
| match = (IRI) subj; |
| break; // Found |
| } |
| } |
| } |
| log.debug("Matching IRI in graph : {}", match); |
| if (match == null) return new IRI(OntologyUtils.encode(publicKey)); |
| else return match; |
| |
| } |
| |
| private void checkHandle(IRI candidate, Set<OntologyCollector> handles) { |
| |
| /* |
| * We have to do it like this because we cannot make this class a Component and reference ONManager |
| * and SessionManager, otherwise an activation cycle will occur. |
| */ |
| ScopeManager scopeManager = ScopeManagerImpl.get(); // FIXME get rid of this. |
| SessionManager sessionManager = SessionManagerImpl.get(); |
| String prefix_scope = _NS_STANBOL_INTERNAL + Scope.shortName + "/", prefix_session = _NS_STANBOL_INTERNAL |
| + Session.shortName |
| + "/"; |
| |
| // TODO check when not explicitly typed. |
| SpaceType spaceType; |
| if (meta.contains(new TripleImpl(candidate, RDF.type, SPACE_URIREF))) { |
| RDFTerm rScope; |
| Iterator<Triple> parentSeeker = meta.filter(candidate, IS_SPACE_CORE_OF_URIREF, null); |
| if (parentSeeker.hasNext()) { |
| rScope = parentSeeker.next().getObject(); |
| spaceType = SpaceType.CORE; |
| } else { |
| parentSeeker = meta.filter(candidate, IS_SPACE_CUSTOM_OF_URIREF, null); |
| if (parentSeeker.hasNext()) { |
| rScope = parentSeeker.next().getObject(); |
| spaceType = SpaceType.CUSTOM; |
| } else { |
| parentSeeker = meta.filter(null, HAS_SPACE_CORE_URIREF, candidate); |
| if (parentSeeker.hasNext()) { |
| rScope = parentSeeker.next().getSubject(); |
| spaceType = SpaceType.CORE; |
| } else { |
| parentSeeker = meta.filter(null, HAS_SPACE_CUSTOM_URIREF, candidate); |
| if (parentSeeker.hasNext()) { |
| rScope = parentSeeker.next().getSubject(); |
| spaceType = SpaceType.CUSTOM; |
| } else throw new InvalidMetaGraphStateException("Ontology space " + candidate |
| + " does not declare a parent scope."); |
| } |
| } |
| } |
| if (!(rScope instanceof IRI)) throw new InvalidMetaGraphStateException( |
| rScope + " is not a legal scope identifier."); |
| String scopeId = ((IRI) rScope).getUnicodeString().substring(prefix_scope.length()); |
| Scope scope = scopeManager.getScope(scopeId); |
| switch (spaceType) { |
| case CORE: |
| handles.add(scope.getCoreSpace()); |
| break; |
| case CUSTOM: |
| handles.add(scope.getCustomSpace()); |
| break; |
| } |
| } else if (meta.contains(new TripleImpl(candidate, RDF.type, SESSION_URIREF))) { |
| String sessionId = candidate.getUnicodeString().substring(prefix_session.length()); |
| handles.add(sessionManager.getSession(sessionId)); |
| } |
| } |
| |
| @Override |
| public void clearDependencies(OWLOntologyID dependent) { |
| if (dependent == null) throw new IllegalArgumentException("dependent cannot be null"); |
| log.debug("Clearing dependencies for {}", dependent); |
| |
| Set<Triple> dependencies = new HashSet<Triple>(); |
| synchronized (meta) { |
| Set<OWLOntologyID> aliases = listAliases(dependent); |
| aliases.add(dependent); |
| for (OWLOntologyID depalias : aliases) { |
| IRI dep = buildResource(depalias); |
| Iterator<Triple> it = meta.filter(dep, DEPENDS_ON_URIREF, null); |
| while (it.hasNext()) { |
| Triple t = it.next(); |
| dependencies.add(t); |
| log.debug(" ... Set {} as a dependency to remove.", t.getObject()); |
| } |
| it = meta.filter(null, HAS_DEPENDENT_URIREF, dep); |
| while (it.hasNext()) { |
| Triple t = it.next(); |
| dependencies.add(t); |
| log.debug(" ... Set {} as a dependency to remove.", t.getSubject()); |
| } |
| } |
| meta.removeAll(dependencies); |
| } |
| log.debug(" ... DONE clearing dependencies."); |
| } |
| |
| @Override |
| public Set<OWLOntologyID> getDependencies(OWLOntologyID dependent) { |
| Set<OWLOntologyID> dependencies = new HashSet<OWLOntologyID>(); |
| log.debug("Getting dependencies for {}", dependent); |
| synchronized (meta) { |
| Set<OWLOntologyID> aliases = listAliases(dependent); |
| aliases.add(dependent); |
| for (OWLOntologyID depalias : aliases) { |
| IRI dep = buildResource(depalias); |
| Iterator<Triple> it = meta.filter(dep, DEPENDS_ON_URIREF, null); |
| while (it.hasNext()) { |
| RDFTerm obj = it.next().getObject(); |
| log.debug(" ... found {} (inverse).", obj); |
| if (obj instanceof IRI) dependencies.add(buildPublicKey((IRI) obj)); |
| else log.warn(" ... Unexpected literal value!"); |
| } |
| it = meta.filter(null, HAS_DEPENDENT_URIREF, dep); |
| while (it.hasNext()) { |
| RDFTerm sub = it.next().getSubject(); |
| log.debug(" ... found {} (inverse).", sub); |
| if (sub instanceof IRI) dependencies.add(buildPublicKey((IRI) sub)); |
| else log.warn(" ... Unexpected literal value!"); |
| } |
| } |
| } |
| return dependencies; |
| } |
| |
| @Override |
| public Set<OWLOntologyID> getDependents(OWLOntologyID dependency) { |
| Set<OWLOntologyID> dependents = new HashSet<OWLOntologyID>(); |
| IRI dep = buildResource(dependency); |
| log.debug("Getting depents for {}", dependency); |
| synchronized (meta) { |
| Iterator<Triple> it = meta.filter(null, DEPENDS_ON_URIREF, dep); |
| while (it.hasNext()) { |
| RDFTerm sub = it.next().getSubject(); |
| log.debug(" ... found {} (inverse).", sub); |
| if (sub instanceof IRI) dependents.add(buildPublicKey((IRI) sub)); |
| else log.warn(" ... Unexpected literal value!"); |
| } |
| it = meta.filter(dep, HAS_DEPENDENT_URIREF, null); |
| while (it.hasNext()) { |
| RDFTerm obj = it.next().getObject(); |
| log.debug(" ... found {} (inverse).", obj); |
| if (obj instanceof IRI) dependents.add(buildPublicKey((IRI) obj)); |
| else log.warn(" ... Unexpected literal value!"); |
| } |
| } |
| return dependents; |
| } |
| |
| @Override |
| public Set<OntologyCollector> getHandles(OWLOntologyID publicKey) { |
| Set<OntologyCollector> handles = new HashSet<OntologyCollector>(); |
| Set<OWLOntologyID> aliases = listAliases(publicKey); |
| aliases.add(publicKey); |
| for (OWLOntologyID alias : aliases) { |
| IRI ontologyId = buildResource(alias); |
| |
| for (Iterator<Triple> it = meta.filter(null, MANAGES_URIREF, ontologyId); it.hasNext();) { |
| BlankNodeOrIRI sub = it.next().getSubject(); |
| if (sub instanceof IRI) checkHandle((IRI) sub, handles); |
| else throw new InvalidMetaGraphStateException( |
| sub + " is not a valid ontology collector identifer."); |
| } |
| |
| for (Iterator<Triple> it = meta.filter(ontologyId, IS_MANAGED_BY_URIREF, null); it.hasNext();) { |
| RDFTerm obj = it.next().getObject(); |
| if (obj instanceof IRI) checkHandle((IRI) obj, handles); |
| else throw new InvalidMetaGraphStateException( |
| obj + " is not a valid ontology collector identifer."); |
| } |
| } |
| return handles; |
| // throw new UnsupportedOperationException("Not implemented yet."); |
| } |
| |
| private IRI getIRIforScope(String scopeId) { |
| // Use the Stanbol-internal namespace, so that the whole configuration can be ported. |
| return new IRI(_NS_STANBOL_INTERNAL + Scope.shortName + "/" + scopeId); |
| } |
| |
| private IRI getIRIforSession(Session session) { |
| // Use the Stanbol-internal namespace, so that the whole configuration can be ported. |
| return new IRI(_NS_STANBOL_INTERNAL + Session.shortName + "/" + session.getID()); |
| } |
| |
| private IRI getIRIforSpace(OntologySpace space) { |
| // Use the Stanbol-internal namespace, so that the whole configuration can be ported. |
| return new IRI(_NS_STANBOL_INTERNAL + OntologySpace.shortName + "/" + space.getID()); |
| } |
| |
| @Override |
| public OWLOntologyID getPublicKey(String stringForm) { |
| if (stringForm == null || stringForm.trim().isEmpty()) throw new IllegalArgumentException( |
| "String form must not be null or empty."); |
| return buildPublicKey(new IRI(stringForm)); |
| } |
| |
| @Override |
| public Set<OWLOntologyID> getPublicKeys() { |
| Set<OWLOntologyID> result = new HashSet<OWLOntologyID>(); |
| Iterator<Triple> it = meta.filter(null, RDF.type, ENTRY_URIREF); |
| while (it.hasNext()) { |
| RDFTerm obj = it.next().getSubject(); |
| if (obj instanceof IRI) result.add(buildPublicKey((IRI) obj)); |
| } |
| return result; |
| } |
| |
| @Override |
| public int getSize(OWLOntologyID publicKey) { |
| IRI subj = buildResource(publicKey); |
| Iterator<Triple> it = meta.filter(subj, SIZE_IN_TRIPLES_URIREF, null); |
| if (it.hasNext()) { |
| RDFTerm obj = it.next().getObject(); |
| if (obj instanceof Literal) { |
| String s = ((Literal) obj).getLexicalForm(); |
| try { |
| return Integer.parseInt(s); |
| } catch (Exception ex) { |
| log.warn("Not a valid integer value {} for size of {}", s, publicKey); |
| return -1; |
| } |
| } |
| } |
| return 0; |
| } |
| |
| /* |
| * XXX see if we can use reasoners, either live or by caching materialisations. |
| */ |
| protected Set<OWLOntologyID> listAliases(OWLOntologyID publicKey) { |
| if (publicKey == null || publicKey.isAnonymous()) throw new IllegalArgumentException( |
| "Cannot locate aliases for null or anonymous public keys."); |
| Set<OWLOntologyID> aliases = new HashSet<OWLOntologyID>(); |
| IRI ont = buildResource(publicKey); |
| // Forwards |
| for (Iterator<Triple> it = meta.filter(ont, OWL.sameAs, null); it.hasNext();) { |
| RDFTerm r = it.next().getObject(); |
| if (r instanceof IRI) aliases.add(buildPublicKey((IRI) r)); |
| } |
| // Backwards |
| for (Iterator<Triple> it = meta.filter(null, OWL.sameAs, ont); it.hasNext();) { |
| RDFTerm r = it.next().getSubject(); |
| if (r instanceof IRI) aliases.add(buildPublicKey((IRI) r)); |
| } |
| return aliases; |
| } |
| |
| @Override |
| public void onOntologyAdded(OntologyCollector collector, OWLOntologyID addedOntology) { |
| // When the ontology provider hears an ontology has been added to a collector, it has to register this |
| // into the metadata graph. |
| |
| // log.info("Heard addition of ontology {} to collector {}", addedOntology, collector.getID()); |
| // log.info("This ontology is stored as {}", getKey(addedOntology)); |
| |
| String colltype = ""; |
| if (collector instanceof Scope) colltype = Scope.shortName + "/"; // Cannot be |
| else if (collector instanceof OntologySpace) colltype = OntologySpace.shortName + "/"; |
| else if (collector instanceof Session) colltype = Session.shortName + "/"; |
| IRI c = new IRI(_NS_STANBOL_INTERNAL + colltype + collector.getID()); |
| IRI u = |
| // new IRI(prefix + "::" + keymap.buildResource(addedOntology).getUnicodeString()); |
| // keymap.getMapping(addedOntology); |
| buildResource(addedOntology); |
| |
| // TODO OntologyProvider should not be aware of scopes, spaces or sessions. Move elsewhere. |
| boolean hasValues = false; |
| log.debug("Ontology {}", addedOntology); |
| log.debug("-- is already managed by the following collectors :"); |
| for (Iterator<Triple> it = meta.filter(u, IS_MANAGED_BY_URIREF, null); it.hasNext();) { |
| hasValues = true; |
| log.debug("-- {}", it.next().getObject()); |
| } |
| for (Iterator<Triple> it = meta.filter(null, MANAGES_URIREF, u); it.hasNext();) { |
| hasValues = true; |
| log.debug("-- {} (inverse)", it.next().getSubject()); |
| } |
| if (!hasValues) log.debug("-- <none>"); |
| |
| // Add both inverse triples. This graph has to be traversed efficiently, no need for reasoners. |
| IRI predicate1 = null, predicate2 = null; |
| if (collector instanceof OntologySpace) { |
| predicate1 = MANAGES_URIREF; |
| predicate2 = IS_MANAGED_BY_URIREF; |
| } else if (collector instanceof Session) { |
| // TODO implement model for sessions. |
| predicate1 = MANAGES_URIREF; |
| predicate2 = IS_MANAGED_BY_URIREF; |
| } else { |
| log.error("Unrecognized ontology collector type {} for \"{}\". Aborting.", collector.getClass(), |
| collector.getID()); |
| return; |
| } |
| if (u != null) synchronized (meta) { |
| Triple t; |
| if (predicate1 != null) { |
| t = new TripleImpl(c, predicate1, u); |
| boolean b = meta.add(t); |
| log.debug((b ? "Successful" : "Redundant") + " addition of meta triple"); |
| log.debug("-- {} ", t); |
| } |
| if (predicate2 != null) { |
| t = new TripleImpl(u, predicate2, c); |
| boolean b = meta.add(t); |
| log.debug((b ? "Successful" : "Redundant") + " addition of meta triple"); |
| log.debug("-- {} ", t); |
| } |
| } |
| } |
| |
| @Override |
| public void onOntologyRemoved(OntologyCollector collector, OWLOntologyID removedOntology) { |
| |
| log.info("Heard removal of ontology {} from collector {}", removedOntology, collector.getID()); |
| |
| String colltype = ""; |
| if (collector instanceof Scope) colltype = Scope.shortName + "/"; // Cannot be |
| else if (collector instanceof OntologySpace) colltype = OntologySpace.shortName + "/"; |
| else if (collector instanceof Session) colltype = Session.shortName + "/"; |
| IRI c = new IRI(_NS_STANBOL_INTERNAL + colltype + collector.getID()); |
| Set<OWLOntologyID> aliases = listAliases(removedOntology); |
| aliases.add(removedOntology); |
| boolean badState = true; |
| for (OWLOntologyID alias : aliases) { |
| IRI u = buildResource(alias); |
| // XXX condense the following code |
| |
| log.debug("Checking ({},{}) pattern", c, u); |
| for (Iterator<Triple> it = meta.filter(c, null, u); it.hasNext();) { |
| IRI property = it.next().getPredicate(); |
| if (collector instanceof OntologySpace || collector instanceof Session) { |
| if (property.equals(MANAGES_URIREF)) badState = false; |
| } |
| } |
| |
| log.debug("Checking ({},{}) pattern", u, c); |
| for (Iterator<Triple> it = meta.filter(u, null, c); it.hasNext();) { |
| IRI property = it.next().getPredicate(); |
| if (collector instanceof OntologySpace || collector instanceof Session) { |
| if (property.equals(IS_MANAGED_BY_URIREF)) badState = false; |
| } |
| } |
| |
| synchronized (meta) { |
| if (collector instanceof OntologySpace || collector instanceof Session) { |
| meta.remove(new TripleImpl(c, MANAGES_URIREF, u)); |
| meta.remove(new TripleImpl(u, IS_MANAGED_BY_URIREF, c)); |
| } |
| } |
| } |
| if (badState) throw new InvalidMetaGraphStateException( |
| "No relationship found between ontology collector " + c + " and stored ontology " |
| + removedOntology + " (or its aliases)."); |
| |
| } |
| |
| @Override |
| public void removeDependency(OWLOntologyID dependent, OWLOntologyID dependency) { |
| if (dependent == null) throw new IllegalArgumentException("dependent cannot be null"); |
| if (dependency == null) throw new IllegalArgumentException("dependency cannot be null"); |
| log.debug("Removing dependency."); |
| log.debug(" ... dependent : {}", dependent); |
| log.debug(" ... dependency : {}", dependency); |
| IRI depy = buildResource(dependency); |
| synchronized (meta) { |
| Set<OWLOntologyID> aliases = listAliases(dependent); |
| aliases.add(dependent); |
| for (OWLOntologyID depalias : aliases) { |
| IRI dep = buildResource(depalias); |
| Triple t = new TripleImpl(dep, DEPENDS_ON_URIREF, depy); |
| boolean found = false; |
| if (meta.contains(t)) { |
| found = true; |
| meta.remove(t); |
| } |
| t = new TripleImpl(depy, HAS_DEPENDENT_URIREF, dep); |
| if (meta.contains(t)) { |
| found = true; |
| meta.remove(t); |
| } |
| if (!found) log.warn("No such dependency found."); |
| else log.debug("DONE removing dependency."); |
| } |
| } |
| } |
| |
| @Override |
| public void scopeActivated(Scope scope) {} |
| |
| @Override |
| public void scopeAppended(Session session, String scopeId) { |
| final IRI sessionur = getIRIforSession(session), scopeur = getIRIforScope(scopeId); |
| if (sessionur == null || scopeur == null) throw new IllegalArgumentException( |
| "IRIs for scope and session cannot be null."); |
| if (meta instanceof Graph) synchronized (meta) { |
| meta.add(new TripleImpl(sessionur, HAS_APPENDED_URIREF, scopeur)); |
| meta.add(new TripleImpl(scopeur, APPENDED_TO_URIREF, sessionur)); |
| } |
| } |
| |
| @Override |
| public void scopeCreated(Scope scope) {} |
| |
| @Override |
| public void scopeDeactivated(Scope scope) {} |
| |
| @Override |
| public void scopeDetached(Session session, String scopeId) { |
| final IRI sessionur = getIRIforSession(session), scopeur = getIRIforScope(scopeId); |
| if (sessionur == null || scopeur == null) throw new IllegalArgumentException( |
| "IRIs for scope and session cannot be null."); |
| if (meta instanceof Graph) synchronized (meta) { |
| // TripleImpl implements equals() and hashCode() ... |
| meta.remove(new TripleImpl(sessionur, HAS_APPENDED_URIREF, scopeur)); |
| meta.remove(new TripleImpl(scopeur, APPENDED_TO_URIREF, sessionur)); |
| } |
| } |
| |
| @Override |
| public void scopeRegistered(Scope scope) { |
| updateScopeRegistration(scope); |
| } |
| |
| @Override |
| public void scopeUnregistered(Scope scope) { |
| updateScopeUnregistration(scope); |
| } |
| |
| @Override |
| public void sessionChanged(SessionEvent event) { |
| switch (event.getOperationType()) { |
| case CREATE: |
| updateSessionRegistration(event.getSession()); |
| break; |
| case KILL: |
| updateSessionUnregistration(event.getSession()); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| @Override |
| public void setDependency(OWLOntologyID dependent, OWLOntologyID dependency) { |
| if (dependent == null) throw new IllegalArgumentException("dependent cannot be null"); |
| if (dependency == null) throw new IllegalArgumentException("dependency cannot be null"); |
| log.debug("Setting dependency."); |
| log.debug(" ... dependent : {}", dependent); |
| log.debug(" ... dependency : {}", dependency); |
| IRI dep = buildResource(dependent), depy = buildResource(dependency); |
| // TODO check for the actual resource! |
| synchronized (meta) { |
| meta.add(new TripleImpl(dep, DEPENDS_ON_URIREF, depy)); |
| } |
| log.debug("DONE setting dependency."); |
| } |
| |
| /** |
| * Write registration info for a new ontology scope and its spaces. |
| * |
| * @param scope |
| * the scope whose information needs to be updated. |
| */ |
| private void updateScopeRegistration(Scope scope) { |
| final IRI scopeur = getIRIforScope(scope.getID()); |
| final IRI coreur = getIRIforSpace(scope.getCoreSpace()); |
| final IRI custur = getIRIforSpace(scope.getCustomSpace()); |
| // If this method was called after a scope rebuild, the following will have little to no effect. |
| synchronized (meta) { |
| // Spaces are created along with the scope, so it is safe to add their triples. |
| meta.add(new TripleImpl(scopeur, RDF.type, SCOPE_URIREF)); |
| meta.add(new TripleImpl(coreur, RDF.type, SPACE_URIREF)); |
| meta.add(new TripleImpl(custur, RDF.type, SPACE_URIREF)); |
| meta.add(new TripleImpl(scopeur, HAS_SPACE_CORE_URIREF, coreur)); |
| meta.add(new TripleImpl(scopeur, HAS_SPACE_CUSTOM_URIREF, custur)); |
| // Add inverse predicates so we can traverse the graph in both directions. |
| meta.add(new TripleImpl(coreur, IS_SPACE_CORE_OF_URIREF, scopeur)); |
| meta.add(new TripleImpl(custur, IS_SPACE_CUSTOM_OF_URIREF, scopeur)); |
| } |
| log.debug("Ontology collector information triples added for scope \"{}\".", scope); |
| } |
| |
| /** |
| * Remove all information on a deregistered ontology scope and its spaces. |
| * |
| * @param scope |
| * the scope whose information needs to be updated. |
| */ |
| private void updateScopeUnregistration(Scope scope) { |
| long before = System.currentTimeMillis(); |
| boolean removable = false, conflict = false; |
| final IRI scopeur = getIRIforScope(scope.getID()); |
| final IRI coreur = getIRIforSpace(scope.getCoreSpace()); |
| final IRI custur = getIRIforSpace(scope.getCustomSpace()); |
| Set<Triple> removeUs = new HashSet<Triple>(); |
| for (Iterator<Triple> it = meta.filter(scopeur, null, null); it.hasNext();) { |
| Triple t = it.next(); |
| if (RDF.type.equals(t.getPredicate())) { |
| if (SCOPE_URIREF.equals(t.getObject())) removable = true; |
| else conflict = true; |
| } |
| removeUs.add(t); |
| } |
| if (!removable) { |
| log.error("Cannot write scope deregistration to persistence:"); |
| log.error("-- resource {}", scopeur); |
| log.error("-- is not typed as a {} in the meta-graph.", SCOPE_URIREF); |
| } else if (conflict) { |
| log.error("Conflict upon scope deregistration:"); |
| log.error("-- resource {}", scopeur); |
| log.error("-- has incompatible types in the meta-graph."); |
| } else { |
| log.debug("Removing all triples for scope \"{}\".", scope.getID()); |
| Iterator<Triple> it; |
| for (it = meta.filter(null, null, scopeur); it.hasNext();) |
| removeUs.add(it.next()); |
| for (it = meta.filter(null, null, coreur); it.hasNext();) |
| removeUs.add(it.next()); |
| for (it = meta.filter(coreur, null, null); it.hasNext();) |
| removeUs.add(it.next()); |
| for (it = meta.filter(null, null, custur); it.hasNext();) |
| removeUs.add(it.next()); |
| for (it = meta.filter(custur, null, null); it.hasNext();) |
| removeUs.add(it.next()); |
| meta.removeAll(removeUs); |
| log.debug("Done; removed {} triples in {} ms.", removeUs.size(), System.currentTimeMillis() |
| - before); |
| } |
| } |
| |
| private void updateSessionRegistration(Session session) { |
| final IRI sesur = getIRIforSession(session); |
| // If this method was called after a session rebuild, the following will have little to no effect. |
| synchronized (meta) { |
| // The only essential triple to add is typing |
| meta.add(new TripleImpl(sesur, RDF.type, SESSION_URIREF)); |
| } |
| log.debug("Ontology collector information triples added for session \"{}\".", sesur); |
| } |
| |
| private void updateSessionUnregistration(Session session) { |
| long before = System.currentTimeMillis(); |
| boolean removable = false, conflict = false; |
| final IRI sessionur = getIRIforSession(session); |
| Set<Triple> removeUs = new HashSet<Triple>(); |
| for (Iterator<Triple> it = meta.filter(sessionur, null, null); it.hasNext();) { |
| Triple t = it.next(); |
| if (RDF.type.equals(t.getPredicate())) { |
| if (SESSION_URIREF.equals(t.getObject())) removable = true; |
| else conflict = true; |
| } |
| removeUs.add(t); |
| } |
| if (!removable) { |
| log.error("Cannot write session deregistration to persistence:"); |
| log.error("-- resource {}", sessionur); |
| log.error("-- is not typed as a {} in the meta-graph.", SESSION_URIREF); |
| } else if (conflict) { |
| log.error("Conflict upon session deregistration:"); |
| log.error("-- resource {}", sessionur); |
| log.error("-- has incompatible types in the meta-graph."); |
| } else { |
| log.debug("Removing all triples for session \"{}\".", session.getID()); |
| Iterator<Triple> it; |
| for (it = meta.filter(null, null, sessionur); it.hasNext();) |
| removeUs.add(it.next()); |
| for (it = meta.filter(sessionur, null, null); it.hasNext();) |
| removeUs.add(it.next()); |
| meta.removeAll(removeUs); |
| log.debug("Done; removed {} triples in {} ms.", removeUs.size(), System.currentTimeMillis() |
| - before); |
| } |
| } |
| |
| } |
