KAON Distribution

This is the distribution of KAON v1.2.7.

Contents:

  1. System Requirements and Installation
  2. Directory Structure
  3. RDF Server
  4. KAON Engineering Server
  5. KAON Portal
  6. RDF Crawler
  7. GUI
  8. KAON Libraries
  9. Source Code
  10. Acknowledgements

KAON is distributed under the LGPL software license. Please refer to http://www.gnu.org/licenses/lgpl.html for the license text.

1. System Requirements and Installation

KAON has been designed to work with 1.4-compatible JDK. It has been tested with Sun's 1.4.1_01 version. All other versions of JDK will not work, including the the 1.4.0, which has a bug that prevents using virtually any KAON functionality. The JDK must be installed on the system before KAON. Batch scripts shipped with KAON have been designed to work with Windows 2000. They may not work on Windows 9x versions.

RDF Server works with JBoss OpenSource application server (available for free from http://www.jboss.org/), version 3.0.4 running on Sun's JDK. Other versions of application servers will probably not work. To use scripts supplied by KAON, JBOSS_HOME environment variable must point to the root directory of the JBoss installation. If you use a different version of the JBoss, you should replace the JBoss client-side libraries in the KAON distribution in the 3rdparty directory with the corresponding libraries from your distribution.

KAON Portal works with Apache Tomcat running on Sun's JDK. It can be downloaded for free from http://jakarta.apache.org/tomcat/. To use scripts supplied by KAON, CATALINA_HOME environment variable must point to the root directory of the Tomcat installation.

After KAON is unzipped to some directory, to use any of the scripts shipped with KAON, environment variable KAON_ROOT must point to the root of the KAON installation.

2. Directory Structure

. root
readme.html this file
3rdparty third-party libraries that KAON uses
apidoc Javadoc documentation of all of KAON
bin scripts for staring various KAON tools
engineeringserver distribution of the KAON engineering server
ext external libraries (such as JDBC drivers) that depend of the actual installation
doc packed Javadoc documentation about RDF API, KAONAPI, RDF Server
rdfserver distribution of the RDF Server
lib KAON libraries

3. RDF Server

RDF Server enables persisting RDF models in a relational database. The server is realized within J2EE architecture and has been designed to work with JBoss EJB server. After you install JBOSS, make sure that JBOSS_HOME environment variable points to the root of the JBoss distribution, e.g.

    set JBOSS_HOME=C:\java\jboss-3.0.4_tomcat-4.1.12

Binaries for the KAON

3.1. Deploying RDF Server

EJB applications must be deployed. Deployment is an action that registers a J2EE application with an EJB server. Therefore, to use RDF Server, you need to deploy it first. Make sure you install JBoss before proceesing and that JBOSS_HOME environment variable is set as specified earlier.

If JBoss is up and running, RDF Server can be deployed from by invoking <kaon-root>/rdfserver/deploy.bat script. When server is deployed, it will look for KAON data source to connect to the database. Appropriate tables will be created and when deployment process finishes, RDF Server is ready for usage. RDF Server can safely be deployed many times. If during deployment server-specific tables are detected, their content will be kept.

RDF Server can be undeployed from the application server by invoking undeploy.bat command script. Undeploying the server will not erase data in the associated database.

3.2. JBoss With Other Databases

JBoss needs a relational database for data persistence. JBoss configuration determines which relational database is being used. Each database available to JBoss is modeled within JBoss as a data source. Data source with name KAON is used by RDF Server for persistence. JBoss must be configured with appropriate data source. JBoss can work with any database for which JDBC 2.0-compliant JDBC driver exists. This can be done by following a few simple steps. We give examples how to install MS SQL Server - for other databases please refer to the database documentation to find out which drivers and connection strings you must use.

3.3. Importing RDF Models Into RDF Server

When RDF Server is deployed, it will create an empty RDF model. You may want to import some data into RDF Server. There are two tools supplied in the KAON distribution that may be used. These tools may be started by appropriate .bat command files from the <kaon-root>\rdfserver directory.

Loader tool relies on RDF Server for import. To use the tool, you need a running instance of RDF Server. The tool may be started by typing

    loader [<rdf-URL> [<alias> [<default-namespace> [<host-name> [<host-port>]]]]]

You don't need to supply any parameters oon the command line. The tool will prompt you for parameters that are missing. This tool should be used for importing into existing models. The program will run slowly, because before each RDF statement is persisted to the model, a check will be performed whether a statement already exists or not.

In case when users can guarrantee that the RDF model in database is empty, another, much faster tool may be used for import. This tool avoids the usage of JBoss and RDF Server and directly opens a connection to the database. This tool will make no checks whether statements already exist in the database, so make sure you know exactly what you are doing. Otherwise, you may corrupt your database. The tool may be started by typing

    dbloader [<rdf-URL> [<alias> [<default-namespace> [<jdbc-connection-string> [<driver-class>]]]]]

Before starting the tool make sure your JDBC driver is provided within <kaon-root>\ext directory. Since this tool connects to a database directly over JDBC, you need to manually supply JDBC connection string and JDBC driver class name.

As an example, an ontology supplied by KAON can be loaded into MS SQL Server database 'kaon' on localhost, with user sa and password sa in the following way:

    dbloader file:../examples/data/unspsc84.kaon onto uri:default- "jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=kaon;SelectMethod=cursor;user=sa;password=sa" com.microsoft.jdbc.sqlserver.SQLServerDriver

4. KAON Engineering Server

KAON Engineering Server enables persisting KAON ontologies in a relational database. The server may be used within J2EE architecture (with JBoss EJB server) or can access a relational database directly. Using the server over JBoss has an additional feature that one user can see the changes that other users are making as the changes happen. In case of using the server with JBoss, follow the installation procedure for RDF Server, with the difference that you need to deploy the engineering server rather than the RDF server.

The engineering server has been tested with MSL SQL Server 2000. Also, it has successfully been run, but not thoroughly tested on PostgreSQL, IBM DB2 7.2 and Oracle 9i. Although other databases may work, the Hypersonic database will NOT work, since it doesn't support many of standard features of relational databases that are needed for server operation. For IBM DB2 it is important to configure the database to use JDBC 2 - please refer to the DB2 documentation for information on how to perform that.

Before using the server, it is necessary to create the schema in the database. For this please use the tool available for your relational database and execute engineeringserver\schema.sql and engineeringserver\indexes.sql scripts. If these scripts are executed without errors, your server is ready for usage.

5. KAON Portal

KAON Portal is a demonstration how KAON APIs can be used to build Web ontology-based portals. It runs wihtin Tomcat, but Tomcat instance packed with Java Web Services Developer Pack will work also, so you don't need two versions of Tomcat. After you install Tomcat or JWSDP, make sure that environment variable CATALINA_HOME points to the root directory of Tomcat/JWSDP installation.

KAON Portal is distributed within <kaon-root>\kaonportal directory. Before it is used, it must be deployed to the Web Server. This can be done using supplied deploy.bat script. KAON Portal may be removed from the Web server by using supplied undeploy.bat script. Before trying to use KAON Portal, please start Tomcat. KAON Portal cannot be undeploed while Tomcat is running.

Before you start KAON Portal, you need to make sure it will find an ontology. Currently, KAON Portal will look for an ontology in a hard-coded location c:\temp\kaonportal.kaon. Please copy some of the supplied ontologies from <kaon-root>\examples\data to c:\temp and rename it to kaonportal.kaon. In later releases we'll add a configuration mechanism to control ontologies better.

KAON Portal may be accessed from the following URL (assuming that you are trying to access it from the same host where Tomcat is running): http://localhost:8080/kaonportal/dispatcher. If everything worked correctly, you should see the ontology and be able to browse it.

6. RDF Crawler

RDF Crawler is a tool that provides capabilities for collecting RDF statements from Internet pages. It is initialized with a configuration that specifies the list of URLs from which the crawling process should start. A sample configuration is provided in a file available at <kaon-root>\examples\data\rdfcrawler_configuration.rdf. The crawler may be started by invoking the rdfcrawler.bat file and providing the URL of the configuration. For example, provided that the current directory is <kaon-root>\bin, the crawler with given default configuration may be invoked by typing

    rdfcrawler -C file:../examples/data/rdfcrawler_configuration.rdf#example
Parameter -C specifies that the crawler is initialized from a configuration file. The #example at the end of the configuration URL points to the resource defining the configuration inside the RDF file.

7. GUI

KAON comes with a powerful infrastructure for building GUIs, along with some default GUI applications. The default configuration of the GUI may be started by invoking bin\kaongui.bat file. Currently the GUI offers the OI-modeler - the editor for building ontologies.

8. KAON Libraries

Client-side binaries are distributed under <kaon-root>\lib directory. You need to include these libraries in other programs you may be developing. Some libraries depend on third-party libraries, so you may need to include them as well. There are following KAON libraries in lib directory:

rdfapi.jar Cleaned-up version Of Sergey Melnik's RDF API. KAON will not work with original version of the API.
rdfcrawler.jar RDF Crawler that can collect RDF from Internet pages
rdfserver-client.jar Classes needed to access RDF server.
kaonapi.jar KAON API interfaces
datalog.jar Datalog engine for evaluating KAON queries
query.jar Implementation of the KAON query language
apionrdf.jar Implementation of the KAON API over RDF API.
apiproxy.jar Implementation of the KAON API as a client-side proxy for various types of servers.
engineeringserver-client.jarClasses needed to access KAON Engineering server.
lexiconindex.jar Provides searching functionality over an ontology
trie.jar Implementation of trie used for optimized search.
similarity.jar Implementation of similarity matcher for computing similarities between instances.
guibase.jar Library for GUI development
oimodeler.jar Editor for OI-models
kaongui.jar Small glue library used for staring up the default KAON GUI

Following third-party libraries are currently used:

jboss*.jar, log4j.jar JBoss 3.0.4 files needed on the client-side when application is started.

The dependencies are as follows:

rdfapi.jar doesn't need anything
rdfcrawler.jar needs rdfapi.jar
rdfserver-client.jar needs rdfapi.jar and JBoss libraries
kaonapi.jar doesn't need anything
datalog.jar doesn't need anything
query.jar needs datalog.jar
apionrdf.jar needs rdfapi.jar, kaonapi.jar, datalog.jar and query.jar
apiproxy.jar needs kaonapi.jar
engineeringserver-client.jarneeds kaonapi.jar, apiproxy.jar, apionrdf.jar, datalog.jar, query.jar and JBoss libraries
lexiconindex.jar needs kaonapi.jar, apiproxy.jar and engineeringserver-client.jar
trie.jar doesn't need anything
similarity.jar doesn't need anything
guibase.jar doesn't need anything
kaoncorpus.jar needs guibase.jar
oimodeler.jar needs guibase.jar
kaongui.jar needs guibase.jar

9. Source Code

Source code of this release is available at http://sourceforge.net/projects/kaon/. For getting the latest version of source code, please use SourceForge CVS access.

10. Acknowledgements

Active Developers

For any information or problems with KAON, any of the authors will be glad to assist you.

Boris Motik (boris.motik@fzi.de) KAON API, RDF API, build scripts, module organization, KAON Portal, KAON GUI, OI-modeler
Daniel Oberle (oberle@aifb.uni-karlsruhe.de) KAON Server, KAON Views
Ljiljana Stojanovic (stojanov@fzi.de) Evolution within KAON API, Virtual Ontology Proxy
Valentin Zacharias (zach@fzi.de) KAON Portal, similarity measurement
Tammo Riedinger (triedinger@gmx.de) KAON Portal
Touchgraph (http://www.touchgraph.com) This company implemented the original open-source graph layout library that was later refactored and incorporated into KAON.

Alumni

These people were actively involved in KAON:

Alexander Mädche (Alexander.Maedche@de.bosch.com) KAON (Co)founder, Coordination and Management
Raphael Volz (volz@aifb.uni-karlsruhe.de) KAON (Co)founder, KAON API, RDF Server, RDF Crawler, KAON Views, KAON DLP

12. Further Information

The official KAON Web Site has more detailed information. Please regard the Developer Guide to learn more about using KAON modules for your programs.