Author: alexdma
Date: Mon Feb 20 16:53:44 2012
New Revision: 1291368
URL: http://svn.apache.org/viewvc?rev=1291368&view=rev
Log:
Replaced subpages with index.mdtext in ontonet docs
Added:
incubator/stanbol/site/trunk/content/stanbol/docs/trunk/ontologymanager/index.mdtext
incubator/stanbol/site/trunk/content/stanbol/docs/trunk/ontologymanager/ontonet/index.mdtext
incubator/stanbol/site/trunk/content/stanbol/docs/trunk/ontologymanager/registry/index.mdtext
Removed:
incubator/stanbol/site/trunk/content/stanbol/docs/trunk/ontologymanager.mdtext
incubator/stanbol/site/trunk/content/stanbol/docs/trunk/ontologymanager/ontonet.mdtext
incubator/stanbol/site/trunk/content/stanbol/docs/trunk/ontologymanager/registry.mdtext
Modified:
incubator/stanbol/site/trunk/content/stanbol/docs/trunk/components.mdtext
incubator/stanbol/site/trunk/content/stanbol/docs/trunk/ontologymanager/registry/language.mdtext
Modified:
incubator/stanbol/site/trunk/content/stanbol/docs/trunk/components.mdtext
URL:
http://svn.apache.org/viewvc/incubator/stanbol/site/trunk/content/stanbol/docs/trunk/components.mdtext?rev=1291368&r1=1291367&r2=1291368&view=diff
==============================================================================
--- incubator/stanbol/site/trunk/content/stanbol/docs/trunk/components.mdtext
(original)
+++ incubator/stanbol/site/trunk/content/stanbol/docs/trunk/components.mdtext
Mon Feb 20 16:53:44 2012
@@ -21,7 +21,7 @@ We will shortly describe the components
* The [Reasoners](reasoners.html) can be used to automatically infer
additional knowledge. It is used to obtain new facts in the knowledge base,
e.g. if your enhanced content tells you about a shop located in "Montparnasse",
you can infer via a "located-in" relation that the same shop is located in
"Paris", in the "Ãle-de-France" and in "France".
-* The [Ontology Manager](ontologymanager.html) is the facility that manages
your ontologies. Ontologies are used to define the knowledge models that
describe the metadata of content. Additionally, the semantics of your metadata
can be defined through an ontology.
+* The [Ontology Manager](ontologymanager/) is the facility that manages your
ontologies. Ontologies are used to define the knowledge models that describe
the metadata of content. Additionally, the semantics of your metadata can be
defined through an ontology.
* The [CMS Adapter](cmsadapter/) CMS Adapter component acts as a bridge
between JCR/CMIS compliant content management systems and the Apache Stanbol.
It can be used to map existing node structures from JCR/CMIS content
repositories to RDF models or vica versa. It also provides services for the
management of content repository items as [Content
Item](enhancer/contentitem.html)s within Contenthub.
Added:
incubator/stanbol/site/trunk/content/stanbol/docs/trunk/ontologymanager/index.mdtext
URL:
http://svn.apache.org/viewvc/incubator/stanbol/site/trunk/content/stanbol/docs/trunk/ontologymanager/index.mdtext?rev=1291368&view=auto
==============================================================================
---
incubator/stanbol/site/trunk/content/stanbol/docs/trunk/ontologymanager/index.mdtext
(added)
+++
incubator/stanbol/site/trunk/content/stanbol/docs/trunk/ontologymanager/index.mdtext
Mon Feb 20 16:53:44 2012
@@ -0,0 +1,48 @@
+Title: Ontology Manager
+
+The Stanbol Ontology Manager provides a __controlled environment__ for
managing ontologies, __ontology networks__ and user sessions for semantic data
modeled after them. It provides full access to ontologies stored into the
Stanbol persistence layer. Managing an ontology network means that you can
activate or deactivate parts of a complex model from time to time, so that your
data can be viewed and classified under different "logical lenses".
This is especially useful in [Reasoning](reasoners.html) operations.
+
+## Usage Scenarios
+
+### User networks
+
+In your CMS, you might be interested in figuring out the trust and
acquaintance network of its users. This can be a combination of the _asserted_
network (i.e. what other users are included in the contact or friend list of a
given user) with the _inferred_ network (e.g. exclude those who are in the
contact list of a blacklisted user). The latter can be derived from the user
activities over the user-generated content of your CMS (e.g. blogs posts, forum
posts, reviews, tweets, ratings).
+
+Both types of networks can be modelled as ontologies. Models can be build on
the _class_ level, or _TBox_ (e.g. everyone who is an Administrator is also a
User, and collaborates with every other Administrator of the same system) and
on the _instance_ level, or _ABox_ (e.g. John is a friend of Mary, who created
blog post bp345263 on 3/10/2012 at 15:10). These models can all be stored using
the Store facility of the Ontology Manager.
+
+Using a [reasoner](reasoners.html) you can classify all the knowledge loaded
on Stanbol, but this can be a time-consuming process due to classifying
knowledge we are not interested in for this task.
[OntoNet](ontologymanager/ontonet.html) allows you to select only the
"interesting" parts of your knowledge base. For example, if the
knowledge contains classifications of animal species, you may want to
deactivate that model when reasoning on user networks. Likewise, you may want
to consider the user profiles _today_, rather than who was a user's friend five
years ago. Therefore, on the instance level you will exclude the profile
history and only consider today's snapshot.
+
+### Knowledge within content
+
+Hierarchical, tree-like structures are a tried-and-true mechanism for
organizing documents, applications and in fact any content items. What users
are required to do is select _one_ set of criteria and organize the directory
structure accordingly. For instance, if journalists were to classify the
reserch papers on their file system, they could do as follows:
+
+* `articles/mine` (articles authored by the users)
+* `articles/ours` (articles authored by colleagues from the same publication)
+* `articles/others` (articles of any other kind)
+
+This simple structure works well because it creates a perfect partition, i.e.
you will always know in which _one_ of these directories any article should go.
But what if the user also wanted to create directories by year of publication,
or by section (politics, sports etc.)? In a file system it is possible to
create these directories and add symbolic links as needed, but what if the user
does not want to _know_ a priori the categories to create directories for? Why
not have a system that creates them aoutomatically according to the semantics
of content that create "good" directories (e.g. not too many directories with
just one content item)?
+
+Organizing a network of ontologies that describe content items can allow such
an application to be built. Having a dataset that represent the metadata of
content stored in a CMS, it is possible to attach different ontology scopes,
e.g. those with domain knowledge, or with the user's organizational hierarchy.
This "virtual directory" structure can also update automatically as the
knowledge does. For instance, if the user removes another user from a "friends"
list, that user's contributions will also be moved out of a `articles/friends`
directory but stay in a `articles/friends_of_friends` directory.
+
+## Features
+
+A Web __Ontology__ in computer and information science is a shareable
conceptual model of a part of the world <a href="#ref1">[1]</a>. This model
describes concepts terms of their characteristics and their relations with
other concepts. By means of OntoNet, it is possible to improve ontology
managers like this:
+
+* Setup multiple __Ontology networks__ simultaneously, by interconnecting the
knowledge contained in ontologies that normally would not be aware of one
another.
+* Dynamic __(de-)activation__ of parts of any ontology network, as needed by
specific reasoning, rule execution, or other knowledge processing tasks.
+* Organize ontologies into __ontology libraries__, which can be populated by
setting up simple RDF graphs called __registries__.
+* Use Stanbol as a central __ontology repository__ that mirrors the ontologies
scattered aound the Web, so that there will be no need to query more than a
single server for all the formal knowledge managed by the CMS.
+
+### Sub-Components
+
+ - [OntoNet](ontologymanager/ontonet.html) - allows to construct subsets
of the knowledge base managed by Stanbol into OWL/OWL2 <a
href="#ref2">[2]</a>ontology networks
+ - [Registry](ontologymanager/registry.html) - manages ontology libraries
for bootstrapping the network using both external and internal ontologies
+ - Store - create, read, update and delete operations on single
ontologies stored in Stanbol. These operations can be performed on entities,
axioms, and whole ontologies.
+
+## References:
+
+* [1] <a name="ref1"
href="http://tomgruber.org/writing/ontolingua-kaj-1993.pdf";
target="_blank">Ontologies (PDF)</a></li>
+* [2] <a name="ref2" href="http://www.w3.org/TR/owl-overview/";
target="_blank">The OWL 2 ontology language</a></li>
+
+____
+_[Back to components](components.html)_
\ No newline at end of file
Added:
incubator/stanbol/site/trunk/content/stanbol/docs/trunk/ontologymanager/ontonet/index.mdtext
URL:
http://svn.apache.org/viewvc/incubator/stanbol/site/trunk/content/stanbol/docs/trunk/ontologymanager/ontonet/index.mdtext?rev=1291368&view=auto
==============================================================================
---
incubator/stanbol/site/trunk/content/stanbol/docs/trunk/ontologymanager/ontonet/index.mdtext
(added)
+++
incubator/stanbol/site/trunk/content/stanbol/docs/trunk/ontologymanager/ontonet/index.mdtext
Mon Feb 20 16:53:44 2012
@@ -0,0 +1,205 @@
+Title: Ontology Network Manager (OntoNet)
+
+## Terminology
+
+Stanbol OntoNet implements the API section for managing OWL and OWL2
ontologies, in order to prepare them for consumption by reasoning services,
refactorers, rule engines and the like. Ontology management in OntoNet is
sparse and not connected: once loaded internally from their remote locations,
ontologies live and are known within the realm they were loaded in. This allows
loose-coupling and (de-)activation of ontologies in order to scale the data
sets for reasoners to process and optimize them for efficiency.
+
+ <center>
+ <figure>
+ <img width="500px" src="../../../images/ontologymanager/ontonet.png"
alt="OntoNet ontology network structure">
+ <figcaption>Figure 1: an example of OntoNet setup for multiple ontology
networks, showing the orthogonal layering of sessions, scopes and
spaces.</figcaption>
+ <figure>
+ </center>
+
+The following concepts have been introduced with OntoNet:
+
+* __Ontology scope__: a "logical realm" for all the ontologies that encompass
a certain CMS-related set of concepts (such as "User", "ACL", "Event",
"Content", "Domain", "Reengineering", "Community", "Travelling" etc.). Scopes
never inherit from each other, though they can load the same ontologies if need
be.
+
+* __Ontology space__: an access-restricted container for synchronized access
to ontologies within a scope. The ontologies in a scope are loaded within its
set of spaces. An ontology scope contains: (a) one core space, which contains
the immutable set of essential ontologies that describe the scope; (b) one
(possibly empty) custom space, which extends the core space according to
specific CMS needs (e.g. the core space for the User scope may contains
alignments to FOAF).
+
+* Session: a container of (supposedly volatile) semantic data which need to be
intercrossed with one or more Scopes, for stateful management of ontology
networks. It can be used to load instances and reason on them using different
models (one per scope). An OntoNet Session is not equivalent to an HTTP session
(since it can live persistently across multiple HTTP sessions), although its
behaviour can reflect the one of the HTTP session that created it, if required
by the implementation.
+
+--------------------
+
+## Usage
+
+Given the entire knowledge base managed by your CMS, OntoNet allows the
construction and management of ontology networks, programmatically via its Java
API or RESTful Web Services _(see next section for details on the latter)_. A
criterion for choosing the appropriate API can be as follows:
+
+* Stanbol plugins or server software that incorporates Stanbol (e.g. larger
OSGi platforms) should use the Java API.
+
+* Client applications, non-Java CMSs or services decoupled from Stanbol should
use the RESTful API.
+
+* Java-based CMSs can use either API.
+
+### Java API
+
+First and foremost, the concept of __ontology network__ is implicit in the
OntoNet API. There is no such thing as an `OntologyNetwork` type. What you do
is create `OntologyScope` and `Session` objects and link them together at
creation time or when launching a process.
+
+#### Accessing the managers.
+
+First and foremost let us obtain references to the main OntoNet manager
classes. In an OSGi environment they can be obtained by reference:
+
+ @Reference
+ ONManager onMgr;
+
+ @Reference
+ SessionManager sesMgr;
+
+In a non-OSGi environment they must be instantiated as POJOs (Plain Old Java
Objects):
+
+ TODO
+
+#### Managing an ontology scope.
+
+Let us now show an example of how to setup an ontology scope, which you should
use for storing the models for a certain domain of your knowledge base. In this
example we will refer to social networks and communities.
+
+ ScopeRegistry registry = onMgr.getScopeRegistry();
+ OntologyScopeFactory factory
+ = onMgr.getOntologyScopeFactory();
+
+ /*
+ * Here we create a scope called "social" where we intend
+ * to place all the knowledge needed for modeling social
+ * networks and communities.
+ *
+ * Suppose the FOAF and SIOC ontologies are the only ones
+ * we are concerned with at scope creation time. We tell
+ * the scope factory method to fetch them from their
+ * original locations on the Web.
+ */
+ try {
+
+ /*
+ * You can include as many ontology input source as
+ * you want, even none at all.
+ */
+ OntologyScope scope = factory.createOntologyScope(
+ "social",
+ new RootOntologyIRISource(
+ IRI.create("http://xmlns.com/foaf/spec/index.rdf";)),
+ new RootOntologyIRISource(
+ IRI.create("http://rdfs.org/sioc/ns";)));
+
+ /*
+ * Setup the scope, so its ontologies will be available
+ * via the RESTful API
+ */
+ // Lock the ontology scope
+ scope.setUp();
+ // Register the scope and activate it
+ registry.registerScope(scope, true);
+ } catch (OWLOntologyCreationException e1) {
+ /*
+ * Thrown if there was an error creating one of the
+ * ontology sources (e.g. if some URL could not be
+ * resolved or it is not an ontology.
+ */
+ e1.printStackTrace();
+ } catch (DuplicateIDException e1) {
+ /*
+ * Thrown if there is already a scope called "social".
+ * In this case we may decide to use the existing one,
+ * so we get it. Note that wen reusing a scope, you
+ * lose the provilege of writing in its core space.
+ * Only the custom space will be open for modification.
+ */
+ scope = registry.getScope("social");
+ }
+
+If you have not changed any parameters in the OntoNet configuration and have
the Ontology Manager Web Service endpoint up and running, you should be able to
fetch an RDF file at `http://localhost:8080/ontonet/ontology/social`. Let us
check it (in Turtle Syntax):
+
+ % curl -H "Accept: application/turtle"
http://localhost:8080/ontonet/ontology/social
+
+ @prefix xsd: <http://www.w3.org/2001/XMLSchema#> .
+ @prefix owl: <http://www.w3.org/2002/07/owl#> .
+ @prefix :
+ <http://localhost:8080/ontonet/ontology/social#> .
+ @prefix xml: <http://www.w3.org/XML/1998/namespace> .
+ @prefix rdf:
+ <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+ @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+ @base <http://localhost:8080/ontonet/ontology/social> .
+
+ <http://localhost:8080/ontonet/ontology/social>
+ rdf:type owl:Ontology ;
+ owl:imports
+ <http://localhost:8080/ontonet/ontology/social/core> .
+
+Let us take a look at the imported ontology that represents the core space of
the "social" scope.
+
+ % curl -H "Accept: application/turtle"
http://localhost:8080/ontonet/ontology/social/core
+
+ @base
+ <http://localhost:8080/ontonet/ontology/social/core> .
+
+ <http://localhost:8080/ontonet/ontology/social/core>
+ rdf:type owl:Ontology ;
+ owl:imports
+
<http://localhost:8080/ontonet/ontology/social/http://rdfs.org/sioc/ns> ,
+
<http://localhost:8080/ontonet/ontology/social/http://xmlns.com/foaf/0.1/> .
+
+Here are the `owl:imports` statements for the FOAF and SIOC ontologies, which
are hijacked to "internal" versions managed by Stanbol. Of course if a domain
namespace other than "http://localhost:8080/"; was configured, you will see that
one in each import statement.
+
+Also note that the import statement for FOAF ends with
`http://xmlns.com/foaf/0.1/`, which is different from the IRI we passed to
Stanbol `http://xmlns.com/foaf/spec/index.rdf`. This happens because in the
case of FOAF the _physical_ IRI (which must be known a priori) differs from its
_logical_ IRI (which identifies the ontology and is discovered only when the
ontology is read), and OntoNet tends to privilege the logical IRI when one is
found, i.e. when the ontology is not anonymous.
+
+The FOAF and SIOC ontologies are imported by the core space because they were
indicated at _creation_ time.
+
+Of course it is possible to onbtain a Java object for the ontology using the
Java API. Here is how to export an entire scope to an OWL API object of type
`OWLOntology`:
+
+ /*
+ * To obtain the OWLOntology, we must specify its class as
+ * a return parameter.
+ * We also set the second argument to true, to specifiy
+ * that we want it merged with its imports, so that the
+ * resulting object contains all axioms.
+ */
+ OWLOntology scopeAsOWL
+ = scope.export(OWLOntology.class, true);
+
+An scope can be exported either as an OWL API object or as a Clerezza object.
+
+ /*
+ * In Clerezza, a Graph is a subclass of TripleCollection,
+ * so it is supported by OntoNet. We could also export a
+ * scope to a MGraph (modifiable Graph).
+ */
+ Graph scopeAsClerezza = scope.export(Graph, false);
+
+
+#### Ontology input sources.
+
+Note that when you add an ontology to a space or session, you pass it an
`OntologyInputSource` object, or more precisely, an `OntologyInputSource<O,P>`.
This is because there can be several ways to obtain an ontology, and those most
common are supported in Stanbol. For example, it can be obtained by
defererencing a IRI and parsing its source code (in RDF/XML, Turtle, etc.), or
by reading an input stream, or taking an already stored RDF graph in the
Stanbol store; or it could be an ontology Java object created from scratch. An
__Ontology input source__ is an object that incorporates (1) the "method" by
which an ontology should be accessed; (2) the type of Java object it should
create to represent an ontology; (3) where it should store the ontology.
+
+* __`OWLOntology` input sources__ comply with the OWL API specification <a
href="#ref1">[1]</a> and creates objects of type `OWLOntology` stored in an
_in-memory_ `OWLOntologyManager`. It will be stored persistently once added to
an ontology network.
+ * `RootOntologySource`. Wraps an already existing `OWLOntology`, therefore
it does not provide a physical IRI.
+ * `RootOntologyIRISource`. Tries to locate and load an ontology, and its
imports, from a given IRI. It can use a custom `OWLOntologyManager` as a store,
and can even override any mappers, in order to force-dereference the IRI.
+ * `ParentPathInputSource`. Tries to load an ontology from a root `File`,
and will seek its imports among the files in the same directory as the root
`File`. It also allows a custom `OWLOntologyManager` as a store.
+Loads the ontology source codeWraps an already existing `OWLOntology`,
therefore it does not provide a physical IRI.
+ * `BlankOntologySource`. Creates an `OWLOntology` with no ID and no
axioms. It can be useful for supplying dummy ontologies to methods that will
not admit a null ontology. Note that the blank ontology is not shared: each
`BlankOntologySource` has a distinct blank ontology object, and they are _not_
equal!
+* __`TripleCollection` input sources__ comply with the Apache Clerezza API
specification, which is also the default native implementation of OntoNet. The
resulting ontology is a subtype of `TripleCollection` (`Graph` or `MGraph`) and
uses a `TcProvider` as a store. Depending on the chosen Stanbol storage, it can
be pesistent or in-memory. Generally, these input sources take less memory that
OWL API counterparts, but do not allow RDF graphs to be managed using the OWL
language constructs. Note that any `TripleCollection` can be exported as an
`OWLOntology` afterwards, once stored.
+ * `GraphContentInputSource`. Creates a `TripleCollection` by reading an
input stream, which can be obtained from a file, URL etc. It can use any
`TcProvider` as a store, otherwise it will create an in-memory triple
collection, which will be copied to the Stanbol store when adding the ontology
to a network. If this `TcProvider` is the `TcManager` used by Stanbol, its
triples are not copied across.
+ * `GraphSource`. Wraps an existing `TripleCollection` object. In general,
it does not 'know' where the ontology was stored.
+
+### Service Endpoints
+
+The OntoNet RESTful API is structured as follows:
+
+_(Please note, that the following links to the actual service endpoints link
to a running instance of Apache Stanbol. If you use domains or ports other than
"localhost:8080", then please change accordingly)_
+
+#### Scopes ("/ontonet/ontology")
+* The endpoint @ [/ontonet/ontology](http://localhost:8080/ontonet/ontology)
shows an overview (as an RDF graph or HTML document) of all registered ontology
scopes.
+* An Ontology Scope @ /ontonet/ontology/{scopeId} provides the
de-referenceable OWL form of the ontology scope _scopeId_, inclusive of OWL
import statements for the spaces and ontologies therein.
+
+#### Sessions ("/ontonet/session")
+* The endpoint @ [/ontonet/session](http://localhost:8080/ontonet/session)
shows an overview (as an RDF graph or HTML document) of all open OntoNet
sessions.
+* A Session @ /ontonet/session/{sessionId} provides the de-referenceable OWL
form of the OntoNet Session _sessionId_, inclusive of OWL import statements for
the ontologies therein.
+
+#### Managed Ontologies ("ontonet/{ontologyId}")
+* A Managed Ontology @ /ontonet/{ontologyId}, where _ontologyId_ is the full
logical IRI that identifies the ontology, provides the RDF form of the ontology
with that ID, if that ontology has been stored and is managed by OntoNet (i.e.
is in some scope or session).
+
+## References:
+
+* [1] <a name="ref1" href="http://owlapi.sourceforge.net"; target="_blank">OWL
API</a></li>
+
+____
+_[Back to Ontology Manager](../)_
\ No newline at end of file
Added:
incubator/stanbol/site/trunk/content/stanbol/docs/trunk/ontologymanager/registry/index.mdtext
URL:
http://svn.apache.org/viewvc/incubator/stanbol/site/trunk/content/stanbol/docs/trunk/ontologymanager/registry/index.mdtext?rev=1291368&view=auto
==============================================================================
---
incubator/stanbol/site/trunk/content/stanbol/docs/trunk/ontologymanager/registry/index.mdtext
(added)
+++
incubator/stanbol/site/trunk/content/stanbol/docs/trunk/ontologymanager/registry/index.mdtext
Mon Feb 20 16:53:44 2012
@@ -0,0 +1,44 @@
+Title: Ontology Registry Manager
+
+Registry management is a facility for Stanbol __administrators__ to
pre-configure sets of ontologies that Stanbol should load and store, or simply
be aware of, _before_ they are included in a part of the ontology network (e.g.
a scope or session). Via the registry manager, it is possible to configure
whether these ontologies should be loaded immediately when Stanbol is
initialized, or only when explicitly requested. The Ontology Registry Manager
is essentially an ontology bookmarker with caching support. It is also possible
to cache multiple versions of the same ontology if needed.
+
+## Terminology
+
+* A __Library__ is a collection of references to ontologies, which can be
located anywhere on the Web. CMS administrators and knowledge managers can
create a library by any criterion, e.g. a library of all _W3C ontologies_, a
library of all the ontologies that describe a _social network_ (which can
include [SIOC](http://sioc-project.org/ontology),
[FOAF](http://xmlns.com/foaf/spec) etc.), a library of _ontology alignments_
(which includes ontologies that align DBPedia to Schema.org, GeoNames to
DBPedia, or a custom product ontology to GoodRelations).
+* A __Registry__ is an RDF resource (i.e. an ontology itself) that describes
one or more libraries. It is the physical object that has to be accessed to
gain knowledge about libraries.
+
+## Usage Scenarios
+
+TODO
+
+## Configuration
+
+Ontology registries (and, by extension, the libraries they reference) are
configured by the Stanbol administrator via the Felix Web console. _Note that
the following links assume Stanbol to be deployed on http://localhost:8080 ._
+
+1. Go to the [Felix console Configuration
Manager](http://localhost:8080/system/console/configMgr) and select __Apache
Stanbol Ontology Registry Manager__ (or follow this [direct
link](http://localhost:8080/system/console/configMgr/org.apache.stanbol.ontologymanager.registry.impl.RegistryManagerImpl))
+2. Under __Registry locations__ you can add or remove the physical URIs of
ontology registries, i.e. RDF resources that contain knowledge about ontology
libraries.
+3. If you wish all the registry contents to be loaded altogether on startup,
uncheck the __lazy ontology loading__ box.
+4. You can select one __Caching policy__ between Centralised (default) and
Distributed. In _Centralised_ caching, all the libraries that reference an
ontology with the same URI will share the very same version of that ontology.
In _Distributed_ caching, each library will reference its own version of each
ontology. Centralised caching is generally recommended, as distributed caching
allows multi-version ontology management, but occupies much more storage space,
depending on the amount of ontologies in common.
+
+## Usage
+
+### Setup an Ontology Registry
+
+To create a Registry, you simply need to make an OWL ontology with certain
types of axioms. See [Registry Language](registry/language.html) for examples
on how to create a Registry and add Library instances to it.
+
+Then upload the ontology on the Web and add it to the __Registry locations__
from the [Felix console
Configuration](http://localhost:8080/system/console/configMgr/org.apache.stanbol.ontologymanager.registry.impl.RegistryManagerImpl).
+
+Note that not only can a single registry describe multiple libraries, but also
multiple registries can describe the same library, each adding information on
the ontologies referenced by it. Library descriptions are _monotonic_, in that
registries can only _add_ information about libraries, never _remove_ any.
+
+### Access a cached ontology
+
+A cached ontology does not need to be loaded into an OntoNet scope or session
in order to be available. It can be accessed at @/ontonet/{ontologyURI} .
+
+### Service Endpoints
+
+Because the configuration of registries is a task for __administrators__ and
is performed through the Felix administration console, there are no RESTful
services for modifying ontology registries. It is however possible to browse
the known ontology libraries.
+
+- [__Libraries__](http://localhost:8080/ontonet/registry). If called from a
Web browser, shows a list of known ontology libraries, and for each of them the
caching state and the number of referenced ontologies. _Note that this service
does not provide information on the registries that describe these libraries;
that is classified information for administrators._ This endpoint supports only
GET with no parameters, and generates text/html only.
+
+____
+_[Back to Ontology Manager](../)_
\ No newline at end of file
Modified:
incubator/stanbol/site/trunk/content/stanbol/docs/trunk/ontologymanager/registry/language.mdtext
URL:
http://svn.apache.org/viewvc/incubator/stanbol/site/trunk/content/stanbol/docs/trunk/ontologymanager/registry/language.mdtext?rev=1291368&r1=1291367&r2=1291368&view=diff
==============================================================================
---
incubator/stanbol/site/trunk/content/stanbol/docs/trunk/ontologymanager/registry/language.mdtext
(original)
+++
incubator/stanbol/site/trunk/content/stanbol/docs/trunk/ontologymanager/registry/language.mdtext
Mon Feb 20 16:53:44 2012
@@ -31,6 +31,6 @@ You can also specify Library-Ontology re
meta:isOntologyOf :SocialOntologies .
____
-_[Back to RegistryOntology Manager](../registry.html)_
+_[Back to Registry Manager](./)_
-_[Back to Ontology Manager](../../ontologymanager.html)_
\ No newline at end of file
+_[Back to Ontology Manager](../)_
\ No newline at end of file
