svn commit: r1086954 [8/16] - in /incubator/stanbol/trunk/kres/ontologymanager/store: ./ api/ api/src/ api/src/main/ api/src/main/java/ api/src/main/java/org/ api/src/main/java/org/apache/ api/src/main/java/org/apache/stanbol/ api/src/main/java/org/apa...

[ci...@apache.org]

Added: incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/JAXBProvider.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/JAXBProvider.java?rev=1086954&view=auto
==============================================================================
--- incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/JAXBProvider.java (added)
+++ incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/JAXBProvider.java Wed Mar 30 13:43:53 2011
@@ -0,0 +1,168 @@
+package org.apache.stanbol.ontologymanager.store.rest;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Type;
+import java.util.List;
+import java.util.Vector;
+
+import javax.ws.rs.Produces;
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.MultivaluedMap;
+import javax.ws.rs.ext.MessageBodyReader;
+import javax.ws.rs.ext.MessageBodyWriter;
+import javax.ws.rs.ext.Provider;
+import javax.xml.XMLConstants;
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBException;
+import javax.xml.bind.Marshaller;
+import javax.xml.bind.Unmarshaller;
+import javax.xml.transform.stream.StreamSource;
+import javax.xml.validation.Schema;
+import javax.xml.validation.SchemaFactory;
+
+import org.apache.stanbol.ontologymanager.store.model.AdministeredOntologies;
+import org.apache.stanbol.ontologymanager.store.model.BuiltInResource;
+import org.apache.stanbol.ontologymanager.store.model.ClassConstraint;
+import org.apache.stanbol.ontologymanager.store.model.ClassContext;
+import org.apache.stanbol.ontologymanager.store.model.ClassMetaInformation;
+import org.apache.stanbol.ontologymanager.store.model.ClassesForOntology;
+import org.apache.stanbol.ontologymanager.store.model.ConstraintType;
+import org.apache.stanbol.ontologymanager.store.model.ContainerClasses;
+import org.apache.stanbol.ontologymanager.store.model.DatatypePropertiesForOntology;
+import org.apache.stanbol.ontologymanager.store.model.DatatypePropertyContext;
+import org.apache.stanbol.ontologymanager.store.model.DisjointClasses;
+import org.apache.stanbol.ontologymanager.store.model.Domain;
+import org.apache.stanbol.ontologymanager.store.model.EquivalentClasses;
+import org.apache.stanbol.ontologymanager.store.model.EquivalentProperties;
+import org.apache.stanbol.ontologymanager.store.model.IndividualContext;
+import org.apache.stanbol.ontologymanager.store.model.IndividualMetaInformation;
+import org.apache.stanbol.ontologymanager.store.model.IndividualsForOntology;
+import org.apache.stanbol.ontologymanager.store.model.ObjectFactory;
+import org.apache.stanbol.ontologymanager.store.model.ObjectPropertiesForOntology;
+import org.apache.stanbol.ontologymanager.store.model.ObjectPropertyContext;
+import org.apache.stanbol.ontologymanager.store.model.OntologyMetaInformation;
+import org.apache.stanbol.ontologymanager.store.model.PropertyAssertions;
+import org.apache.stanbol.ontologymanager.store.model.PropertyMetaInformation;
+import org.apache.stanbol.ontologymanager.store.model.Range;
+import org.apache.stanbol.ontologymanager.store.model.ResourceMetaInformationType;
+import org.apache.stanbol.ontologymanager.store.model.SuperProperties;
+import org.apache.stanbol.ontologymanager.store.model.Superclasses;
+import org.apache.stanbol.ontologymanager.store.rest.util.XMLUtil;
+import org.xml.sax.SAXException;
+
+import com.sun.jersey.spi.resource.Singleton;
+
+@Singleton
+@Provider
+@Produces(MediaType.APPLICATION_XML)
+public class JAXBProvider implements MessageBodyReader, MessageBodyWriter {
+
+    private Marshaller marshaller;
+
+    private Unmarshaller unmarshaller;
+
+    public JAXBProvider() throws JAXBException, SAXException {
+        ClassLoader cl = ObjectFactory.class.getClassLoader();
+        JAXBContext jc = JAXBContext.newInstance("org.apache.stanbol.ontologymanager.store.model", cl);
+        marshaller = jc.createMarshaller();
+        unmarshaller = jc.createUnmarshaller();
+        String schemaLocations[] = {"model/xlinks.xsd", "model/PersistenceStoreRESTfulInterface.xsd",
+                                    "model/SearchRESTfulInterface.xsd"};
+        SchemaFactory schemaFactory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI,
+            "com.sun.org.apache.xerces.internal.jaxp.validation.XMLSchemaFactory",
+            XMLUtil.class.getClassLoader());
+
+        List<StreamSource> streamSourceList = new Vector<StreamSource>();
+        for (int i = 0; i < schemaLocations.length; i++) {
+            InputStream is = cl.getResourceAsStream(schemaLocations[i]);
+            StreamSource streamSource = new StreamSource(is);
+            streamSourceList.add(streamSource);
+        }
+        StreamSource sources[] = new StreamSource[streamSourceList.size()];
+        Schema schema = schemaFactory.newSchema(streamSourceList.toArray(sources));
+        marshaller.setSchema(schema);
+        marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
+        unmarshaller.setSchema(schema);
+    }
+
+    @Override
+    public long getSize(Object t, Class type, Type genericType, Annotation[] annotations, MediaType mediaType) {
+        return -1;
+    }
+
+    @Override
+    public boolean isWriteable(Class type, Type genericType, Annotation[] annotations, MediaType mediaType) {
+        if (type.equals(AdministeredOntologies.class) || type.equals(BuiltInResource.class)
+            || type.equals(ClassConstraint.class) || type.equals(ClassContext.class)
+            || type.equals(ClassesForOntology.class) || type.equals(ClassMetaInformation.class)
+            || type.equals(ConstraintType.class) || type.equals(ContainerClasses.class)
+            || type.equals(DatatypePropertiesForOntology.class) || type.equals(DatatypePropertyContext.class)
+            || type.equals(DisjointClasses.class) || type.equals(Domain.class)
+            || type.equals(EquivalentClasses.class) || type.equals(EquivalentProperties.class)
+            || type.equals(IndividualContext.class) || type.equals(IndividualMetaInformation.class)
+            || type.equals(IndividualsForOntology.class) || type.equals(ObjectPropertiesForOntology.class)
+            || type.equals(ObjectPropertyContext.class) || type.equals(OntologyMetaInformation.class)
+            || type.equals(PropertyAssertions.class) || type.equals(PropertyMetaInformation.class)
+            || type.equals(Range.class) || type.equals(ResourceMetaInformationType.class)
+            || type.equals(Superclasses.class) || type.equals(SuperProperties.class)) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    @Override
+    public void writeTo(Object t,
+                        Class type,
+                        Type genericType,
+                        Annotation[] annotations,
+                        MediaType mediaType,
+                        MultivaluedMap httpHeaders,
+                        OutputStream entityStream) throws IOException, WebApplicationException {
+        try {
+            marshaller.marshal(t, entityStream);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    public boolean isReadable(Class type, Type genericType, Annotation[] annotations, MediaType mediaType) {
+        if (type.equals(AdministeredOntologies.class) || type.equals(BuiltInResource.class)
+            || type.equals(ClassConstraint.class) || type.equals(ClassContext.class)
+            || type.equals(ClassesForOntology.class) || type.equals(ClassMetaInformation.class)
+            || type.equals(ConstraintType.class) || type.equals(ContainerClasses.class)
+            || type.equals(DatatypePropertiesForOntology.class) || type.equals(DatatypePropertyContext.class)
+            || type.equals(DisjointClasses.class) || type.equals(Domain.class)
+            || type.equals(EquivalentClasses.class) || type.equals(EquivalentProperties.class)
+            || type.equals(IndividualContext.class) || type.equals(IndividualMetaInformation.class)
+            || type.equals(IndividualsForOntology.class) || type.equals(ObjectPropertiesForOntology.class)
+            || type.equals(ObjectPropertyContext.class) || type.equals(OntologyMetaInformation.class)
+            || type.equals(PropertyAssertions.class) || type.equals(PropertyMetaInformation.class)
+            || type.equals(Range.class) || type.equals(ResourceMetaInformationType.class)
+            || type.equals(Superclasses.class) || type.equals(SuperProperties.class)) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    @Override
+    public Object readFrom(Class type,
+                           Type genericType,
+                           Annotation[] annotations,
+                           MediaType mediaType,
+                           MultivaluedMap httpHeaders,
+                           InputStream entityStream) throws IOException, WebApplicationException {
+        try {
+            return unmarshaller.unmarshal(entityStream);
+        } catch (JAXBException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+}

Propchange: incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/JAXBProvider.java
------------------------------------------------------------------------------
    svn:executable = *

Added: incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/JerseyApplication.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/JerseyApplication.java?rev=1086954&view=auto
==============================================================================
--- incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/JerseyApplication.java (added)
+++ incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/JerseyApplication.java Wed Mar 30 13:43:53 2011
@@ -0,0 +1,72 @@
+package org.apache.stanbol.ontologymanager.store.rest;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import javax.ws.rs.core.Application;
+
+import org.apache.stanbol.ontologymanager.store.rest.resources.Ontologies;
+import org.apache.stanbol.ontologymanager.store.rest.resources.OntologyClasses;
+import org.apache.stanbol.ontologymanager.store.rest.resources.OntologyDatatypeProperties;
+import org.apache.stanbol.ontologymanager.store.rest.resources.OntologyDump;
+import org.apache.stanbol.ontologymanager.store.rest.resources.OntologyIndividuals;
+import org.apache.stanbol.ontologymanager.store.rest.resources.OntologyObjectProperties;
+import org.apache.stanbol.ontologymanager.store.rest.resources.ParticularClass;
+import org.apache.stanbol.ontologymanager.store.rest.resources.ParticularClassDisjointClasses;
+import org.apache.stanbol.ontologymanager.store.rest.resources.ParticularClassEquivalentClasses;
+import org.apache.stanbol.ontologymanager.store.rest.resources.ParticularClassSuperClasses;
+import org.apache.stanbol.ontologymanager.store.rest.resources.ParticularDatatypeProperty;
+import org.apache.stanbol.ontologymanager.store.rest.resources.ParticularDatatypePropertyDomains;
+import org.apache.stanbol.ontologymanager.store.rest.resources.ParticularDatatypePropertyRanges;
+import org.apache.stanbol.ontologymanager.store.rest.resources.ParticularDatatypePropertySuperProperties;
+import org.apache.stanbol.ontologymanager.store.rest.resources.ParticularIndividual;
+import org.apache.stanbol.ontologymanager.store.rest.resources.ParticularIndividualPropertyAssertions;
+import org.apache.stanbol.ontologymanager.store.rest.resources.ParticularIndividualTypes;
+import org.apache.stanbol.ontologymanager.store.rest.resources.ParticularObjectProperty;
+import org.apache.stanbol.ontologymanager.store.rest.resources.ParticularObjectPropertyDomains;
+import org.apache.stanbol.ontologymanager.store.rest.resources.ParticularObjectPropertyRanges;
+import org.apache.stanbol.ontologymanager.store.rest.resources.ParticularObjectPropertySuperProperties;
+import org.apache.stanbol.ontologymanager.store.rest.resources.ParticularOntology;
+
+public class JerseyApplication extends Application {
+
+    @Override
+    public Set<Class<?>> getClasses() {
+
+        Set<Class<?>> classes = new HashSet<Class<?>>();
+        classes.add(Ontologies.class);
+        classes.add(OntologyClasses.class);
+        classes.add(OntologyDatatypeProperties.class);
+        classes.add(OntologyObjectProperties.class);
+        classes.add(OntologyIndividuals.class);
+        classes.add(ParticularClass.class);
+        classes.add(ParticularDatatypeProperty.class);
+        classes.add(ParticularOntology.class);
+        classes.add(ParticularObjectProperty.class);
+        classes.add(ParticularIndividual.class);
+        classes.add(OntologyDump.class);
+        classes.add(ParticularClassSuperClasses.class);
+        classes.add(ParticularClassDisjointClasses.class);
+        classes.add(ParticularClassEquivalentClasses.class);
+        classes.add(ParticularObjectPropertyRanges.class);
+        classes.add(ParticularObjectPropertyDomains.class);
+        classes.add(ParticularObjectPropertySuperProperties.class);
+        classes.add(ParticularDatatypePropertyDomains.class);
+        classes.add(ParticularDatatypePropertyRanges.class);
+        classes.add(ParticularDatatypePropertySuperProperties.class);
+        classes.add(ParticularIndividualTypes.class);
+        classes.add(ParticularIndividualPropertyAssertions.class);
+
+        classes.add(JAXBProvider.class);
+
+        return classes;
+    }
+
+    @Override
+    public Set<Object> getSingletons() {
+        Set<Object> singletons = new HashSet<Object>();
+        // view processors
+        singletons.add(new FreemarkerViewProcessor());
+        return singletons;
+    }
+}

Propchange: incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/JerseyApplication.java
------------------------------------------------------------------------------
    svn:executable = *

Added: incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/LockManagerImp.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/LockManagerImp.java?rev=1086954&view=auto
==============================================================================
--- incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/LockManagerImp.java (added)
+++ incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/LockManagerImp.java Wed Mar 30 13:43:53 2011
@@ -0,0 +1,120 @@
+package org.apache.stanbol.ontologymanager.store.rest;
+
+import java.util.Hashtable;
+import java.util.List;
+import java.util.Vector;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+import org.apache.felix.scr.annotations.Component;
+import org.apache.felix.scr.annotations.Service;
+import org.apache.stanbol.ontologymanager.store.api.LockManager;
+
+@Component
+@Service
+public class LockManagerImp implements LockManager {
+
+    private Lock internalLock = null;
+    private ReentrantReadWriteLock globalSpaceLock = null;
+    private List<ReentrantReadWriteLock> rwlockList = null;
+    private Hashtable<String,ReentrantReadWriteLock> index = null;
+
+    public LockManagerImp() {
+        rwlockList = new Vector<ReentrantReadWriteLock>();
+        index = new Hashtable<String,ReentrantReadWriteLock>();
+        internalLock = new ReentrantLock();
+        globalSpaceLock = new ReentrantReadWriteLock();
+    }
+
+    private static LockManager instance = null;
+
+    public static LockManager getInstance() {
+        if (instance == null) {
+            instance = new LockManagerImp();
+        }
+        return instance;
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see org.apache.stanbol.ontologymanager.store.rest.ILockManager#obtainReadLockFor(java.lang.String)
+     */
+    public void obtainReadLockFor(String ontologyPath) {
+        if (ontologyPath.equalsIgnoreCase(GLOBAL_SPACE)) {
+            globalSpaceLock.readLock().lock();
+        } else {
+            String closureID = getClosureIDFor(ontologyPath);
+            internalLock.lock();
+            if (!index.containsKey(closureID)) {
+                ReentrantReadWriteLock rrwl = new ReentrantReadWriteLock();
+                rwlockList.add(rrwl);
+                index.put(closureID, rrwl);
+            }
+            internalLock.unlock();
+            ReentrantReadWriteLock rrwl = index.get(closureID);
+            globalSpaceLock.readLock().lock();
+            rrwl.readLock().lock();
+        }
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see org.apache.stanbol.ontologymanager.store.rest.ILockManager#releaseReadLockFor(java.lang.String)
+     */
+    public void releaseReadLockFor(String ontologyPath) {
+        if (ontologyPath.equalsIgnoreCase(GLOBAL_SPACE)) {
+            globalSpaceLock.readLock().unlock();
+        } else {
+            String closureID = getClosureIDFor(ontologyPath);
+            ReentrantReadWriteLock rrwl = index.get(closureID);
+            rrwl.readLock().unlock();
+            globalSpaceLock.readLock().unlock();
+        }
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see org.apache.stanbol.ontologymanager.store.rest.ILockManager#obtainWriteLockFor(java.lang.String)
+     */
+    public void obtainWriteLockFor(String ontologyPath) {
+        if (ontologyPath.equalsIgnoreCase(GLOBAL_SPACE)) {
+            globalSpaceLock.writeLock().lock();
+        } else {
+            String closureID = getClosureIDFor(ontologyPath);
+            internalLock.lock();
+            if (!index.containsKey(closureID)) {
+                ReentrantReadWriteLock rrwl = new ReentrantReadWriteLock();
+                rwlockList.add(rrwl);
+                index.put(closureID, rrwl);
+            }
+            internalLock.unlock();
+            ReentrantReadWriteLock rrwl = index.get(closureID);
+            globalSpaceLock.readLock().lock();
+            rrwl.writeLock().lock();
+        }
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see org.apache.stanbol.ontologymanager.store.rest.ILockManager#releaseWriteLockFor(java.lang.String)
+     */
+    public void releaseWriteLockFor(String ontologyPath) {
+        if (ontologyPath.equalsIgnoreCase(GLOBAL_SPACE)) {
+            globalSpaceLock.writeLock().unlock();
+        } else {
+            String closureID = getClosureIDFor(ontologyPath);
+            ReentrantReadWriteLock rrwl = index.get(closureID);
+            rrwl.writeLock().unlock();
+            globalSpaceLock.readLock().unlock();
+        }
+    }
+
+    private String getClosureIDFor(String ontologyPath) {
+        return ontologyPath;
+    }
+}

Propchange: incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/LockManagerImp.java
------------------------------------------------------------------------------
    svn:executable = *

Added: incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/ResourceManagerImp.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/ResourceManagerImp.java?rev=1086954&view=auto
==============================================================================
--- incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/ResourceManagerImp.java (added)
+++ incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/ResourceManagerImp.java Wed Mar 30 13:43:53 2011
@@ -0,0 +1,665 @@
+package org.apache.stanbol.ontologymanager.store.rest;
+
+import java.io.IOException;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.Dictionary;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.Vector;
+
+import org.apache.felix.scr.annotations.Activate;
+import org.apache.felix.scr.annotations.Component;
+import org.apache.felix.scr.annotations.Service;
+import org.apache.stanbol.ontologymanager.store.api.ResourceManager;
+import org.osgi.service.component.ComponentContext;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Class that relates URL(Path)s used by the RESTful interface with the URIs used by the underlying triple
+ * store
+ * 
+ * @author gunes
+ */
+
+@Component(enabled = true)
+@Service
+public class ResourceManagerImp implements ResourceManager {
+
+    private static final String DB_URL = "jdbc:derby:ps_db;create=true";
+
+    private String DB_DRIVER = "org.apache.derby.jdbc.EmbeddedDriver";
+
+    private static String ontologyPathPrefix = "ontologies/";
+
+    private static String classPathPrefix = "classes/";
+
+    private static String dataPropertyPathPrefix = "datatypeProperties/";
+
+    private static String objectPropertyPathPrefix = "objectProperties/";
+
+    private static String individualPathPrefix = "individuals/";
+
+    private static String ontologiesTable = "resource_manager_ontologies";
+
+    private static String resourcesTable = "resource_manager_resources";
+
+    public static String CLASS_RESOURCE = "CLASS";
+
+    public static String DATA_PROPERTY_RESOURCE = "DATA_PROPERTY";
+
+    public static String OBJECT_PROPERTY_RESOURCE = "OBJECT_PROPERTY";
+
+    public static String INDIVIDUAL_RESOURCE = "INDIVIDUAL";
+
+    Dictionary<String,String> properties = null;
+
+    /** Logger instance **/
+    private static Logger logger = LoggerFactory.getLogger(ResourceManagerImp.class);
+
+    /* private variables to store ontology-path (URI-URL) relations */
+    /* ontologyURI --> ontologyPath */
+    private Hashtable<String,String> ontologies = null;
+
+    /* ontologyPath --> ontologyURI */
+    private Hashtable<String,String> ontologiesInverted = null;
+
+    /*
+     * private varibles to store resource(class/property/individual)-path (resource URI - resource URL)
+     * relations
+     */
+    /* resourceURI --> resourcePath */
+    private Hashtable<String,String> resources = null;
+
+    /* resourcePath --> resourceURI */
+    private Hashtable<String,String> resourcesInverted = null;
+
+    /*
+     * the type of the resource could be values attributed by the static variables: CLASS_RESOURCE,
+     * DATA_PROPERTY_RESOURCE, OBJECT_PROPERTY_RESOURCE and INDIVIDUAL_RESOURCE
+     */
+    /* resourceURI --> resourceType */
+    private Hashtable<String,String> resourcesTypes = null;
+
+    /*
+     * private variable to store the mapping between resource URI - ontology URI, where the resource belongs
+     * to that ontology
+     */
+    /* resourceURI --> ontologyURI */
+    private Hashtable<String,String> resourceToOntologyURIs = null;
+
+    private static ResourceManagerImp INSTANCE = null;
+
+    private void restore() throws IOException {
+        try {
+            Connection con = obtainConnection();
+            Statement statement = con.createStatement();
+
+            boolean ontologiesTableExist = checkTableExists(con, ontologiesTable);
+            boolean resourceTableExist = checkTableExists(con, resourcesTable);
+
+            if (!ontologiesTableExist) {
+                Statement stmt = con.createStatement();
+                String sql = "CREATE TABLE resource_manager_ontologies ("
+                             + "id INTEGER NOT NULL GENERATED ALWAYS AS IDENTITY (START WITH 1, INCREMENT BY 1),"
+                             + "ontologyURI varchar(255) DEFAULT NULL,"
+                             + "ontologyPath varchar(255) DEFAULT NULL," + "PRIMARY KEY (id)" + ")";
+                stmt.executeUpdate(sql);
+            }
+
+            if (!resourceTableExist) {
+                // the table does not exist
+                Statement stmt = con.createStatement();
+                String sql = "CREATE TABLE resource_manager_resources (" + "id INTEGER DEFAULT NULL,"
+                             + "resourceURI varchar(255) DEFAULT NULL,"
+                             + "resourcePath varchar(255) DEFAULT NULL,"
+                             + "resourceType varchar(255) DEFAULT NULL" + ") ";
+                stmt.executeUpdate(sql);
+            }
+
+            ResultSet rSet = statement.executeQuery("SELECT * FROM " + ontologiesTable);
+            while (rSet.next()) {
+                String ontologyURI = rSet.getString("ontologyURI");
+                String ontologyPath = rSet.getString("ontologyPath");
+                ontologies.put(ontologyURI, ontologyPath);
+                ontologiesInverted.put(ontologyPath, ontologyURI);
+            }
+            Statement statement2 = con.createStatement();
+            ResultSet rSet2 = statement2.executeQuery("SELECT * from " + resourcesTable);
+            while (rSet2.next()) {
+                String resourceURI = rSet2.getString("resourceURI");
+                String resourcePath = rSet2.getString("resourcePath");
+                String resourceType = rSet2.getString("resourceType");
+                String ontologyTableRowRef = rSet2.getString("id");
+                Statement statement3 = con.createStatement();
+                ResultSet rSet3 = statement3.executeQuery("SELECT * from " + ontologiesTable + " WHERE id="
+                                                          + ontologyTableRowRef);
+                if (rSet3.next()) {
+                    String ontologyURIForResource = rSet3.getString("ontologyURI");
+                    String ontologyPathForResource = rSet3.getString("ontologyPath");
+                    resources.put(ontologyURIForResource + "#" + resourceURI, resourcePath);
+                    resourcesInverted.put(ontologyPathForResource + "#" + resourcePath, resourceURI);
+                    resourceToOntologyURIs.put(resourceURI, ontologyURIForResource);
+                    resourcesTypes.put(ontologyURIForResource + "#" + resourceURI, resourceType);
+                }
+            }
+            con.close();
+        } catch (Exception e) {
+            throw new RuntimeException("Resource manager can not restore ", e);
+        }
+    }
+
+    private boolean checkTableExists(Connection con, String tableName) throws SQLException {
+        // FIXME This should be done by jdbc's table functionality but it does
+        // not seem to work with Apache Derby
+        Statement stmt = con.createStatement();
+        String stmtString = "SELECT COUNT(*) FROM " + tableName;
+        boolean exists = true;
+        try {
+            stmt.execute(stmtString);
+        } catch (SQLException e) {
+            String state = (e).getSQLState();
+            if ("42X05".equals(state)) exists = false;
+        } finally {
+            stmt.close();
+        }
+        return exists;
+    }
+
+    @Activate
+    public void activate(ComponentContext cc) {
+        try {
+            this.restore();
+        } catch (IOException e) {
+            throw new RuntimeException("Can not restore stored information", e);
+        }
+        logger.info("Resource Manager properties are set");
+    }
+
+    public ResourceManagerImp() {
+        INSTANCE = this;
+        ontologies = new Hashtable<String,String>();
+        ontologiesInverted = new Hashtable<String,String>();
+        resources = new Hashtable<String,String>();
+        resourcesInverted = new Hashtable<String,String>();
+        resourceToOntologyURIs = new Hashtable<String,String>();
+        resourcesTypes = new Hashtable<String,String>();
+    }
+
+    public static ResourceManagerImp getInstance() {
+        if (INSTANCE == null) {
+            INSTANCE = new ResourceManagerImp();
+            // logger.warn("Creating Resource Manager: Properties must be set");
+        } else {}
+
+        return INSTANCE;
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @seeeu.iksproject.fise.stores.persistencestore.rest.IResourceManager#
+     * registerOntology(java.lang.String)
+     */
+    public void registerOntology(String ontologyURI) {
+        try {
+            if (!ontologies.containsKey(ontologyURI)) {
+                String ontologyPath = normalizeURI(ontologyURI);
+                ontologies.put(ontologyURI, ontologyPath);
+                ontologiesInverted.put(ontologyPath, ontologyURI);
+
+                Connection con = obtainConnection();
+                Statement statement = con.createStatement();
+                statement.executeUpdate("INSERT INTO " + ontologiesTable
+                                        + " (ontologyURI, ontologyPath) VALUES ('" + ontologyURI + "', '"
+                                        + ontologyPath + "')");
+                con.close();
+            }
+        } catch (Exception e) {
+            logger.error("Error ", e);
+        }
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @seeeu.iksproject.fise.stores.persistencestore.rest.IResourceManager# registerClass(java.lang.String,
+     * java.lang.String)
+     */
+    public void registerClass(String ontologyURI, String classURI) {
+        try {
+            if (!resources.containsKey(ontologyURI + "#" + classURI)) {
+                String classPath = normalizeURI(classURI);
+                resources.put(ontologyURI + "#" + classURI, classPath);
+                resourcesInverted.put(ontologies.get(ontologyURI) + "#" + classPath, classURI);
+                resourceToOntologyURIs.put(classURI, ontologyURI);
+                resourcesTypes.put(ontologyURI + "#" + classURI, CLASS_RESOURCE);
+                Connection con = obtainConnection();
+                Statement statement = con.createStatement();
+                ResultSet rSet = statement.executeQuery("SELECT id from " + ontologiesTable
+                                                        + " WHERE ontologyURI='" + ontologyURI + "'");
+                if (rSet.next()) {
+                    String ontologyRowID = rSet.getString("id");
+                    statement.executeUpdate("INSERT INTO " + resourcesTable
+                                            + " (id, resourceURI, resourcePath, resourceType) VALUES ("
+                                            + ontologyRowID + ", '" + classURI + "', '" + classPath + "', '"
+                                            + CLASS_RESOURCE + "')");
+                }
+                con.close();
+                // logger.info("Connection Closed");
+            }
+        } catch (Exception e) {
+            logger.error("Error ", e);
+        }
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @seeeu.iksproject.fise.stores.persistencestore.rest.IResourceManager#
+     * registerDatatypeProperty(java.lang.String, java.lang.String)
+     */
+    public void registerDatatypeProperty(String ontologyURI, String dataPropertyURI) {
+        try {
+            if (!resources.containsKey(ontologyURI + "#" + dataPropertyURI)) {
+                String dataPropertyPath = normalizeURI(dataPropertyURI);
+                resources.put(ontologyURI + "#" + dataPropertyURI, dataPropertyPath);
+                resourcesInverted.put(ontologies.get(ontologyURI) + "#" + dataPropertyPath, dataPropertyURI);
+                resourceToOntologyURIs.put(dataPropertyURI, ontologyURI);
+                resourcesTypes.put(ontologyURI + "#" + dataPropertyURI, DATA_PROPERTY_RESOURCE);
+                Connection con = obtainConnection();
+                Statement statement = con.createStatement();
+                ResultSet rSet = statement.executeQuery("SELECT id from " + ontologiesTable
+                                                        + " WHERE ontologyURI='" + ontologyURI + "'");
+                if (rSet.next()) {
+                    String ontologyRowID = rSet.getString("id");
+                    statement.executeUpdate("INSERT INTO " + resourcesTable
+                                            + " (id, resourceURI, resourcePath, resourceType) VALUES ("
+                                            + ontologyRowID + ", '" + dataPropertyURI + "', '"
+                                            + dataPropertyPath + "', '" + DATA_PROPERTY_RESOURCE + "')");
+                }
+                con.close();
+                // logger.info("Connection Closed");
+            }
+        } catch (Exception e) {
+            logger.error("Error ", e);
+        }
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @seeeu.iksproject.fise.stores.persistencestore.rest.IResourceManager#
+     * registerObjectProperty(java.lang.String, java.lang.String)
+     */
+    public void registerObjectProperty(String ontologyURI, String objectPropertyURI) {
+        try {
+            if (!resources.containsKey(ontologyURI + "#" + objectPropertyURI)) {
+                String objectPropertyPath = normalizeURI(objectPropertyURI);
+                resources.put(ontologyURI + "#" + objectPropertyURI, objectPropertyPath);
+                resourcesInverted.put(ontologies.get(ontologyURI) + "#" + objectPropertyPath,
+                    objectPropertyURI);
+                resourceToOntologyURIs.put(objectPropertyURI, ontologyURI);
+                resourcesTypes.put(ontologyURI + "#" + objectPropertyURI, OBJECT_PROPERTY_RESOURCE);
+                Connection con = obtainConnection();
+                Statement statement = con.createStatement();
+                ResultSet rSet = statement.executeQuery("SELECT id from " + ontologiesTable
+                                                        + " WHERE ontologyURI='" + ontologyURI + "'");
+                if (rSet.next()) {
+                    String ontologyRowID = rSet.getString("id");
+                    statement.executeUpdate("INSERT INTO " + resourcesTable
+                                            + " (id, resourceURI, resourcePath, resourceType) VALUES ("
+                                            + ontologyRowID + ", '" + objectPropertyURI + "', '"
+                                            + objectPropertyPath + "', '" + OBJECT_PROPERTY_RESOURCE + "')");
+                }
+                con.close();
+            }
+        } catch (Exception e) {
+            logger.error("Error ", e);
+        }
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @seeeu.iksproject.fise.stores.persistencestore.rest.IResourceManager#
+     * registerIndividual(java.lang.String, java.lang.String)
+     */
+    public void registerIndividual(String ontologyURI, String individualURI) {
+        try {
+            if (!resources.containsKey(ontologyURI + "#" + individualURI)) {
+                String individualPath = normalizeURI(individualURI);
+                resources.put(ontologyURI + "#" + individualURI, individualPath);
+                resourcesInverted.put(ontologies.get(ontologyURI) + "#" + individualPath, individualURI);
+                resourceToOntologyURIs.put(individualURI, ontologyURI);
+                resourcesTypes.put(ontologyURI + "#" + individualURI, INDIVIDUAL_RESOURCE);
+                Connection con = obtainConnection();
+                Statement statement = con.createStatement();
+                ResultSet rSet = statement.executeQuery("SELECT id from " + ontologiesTable
+                                                        + " WHERE ontologyURI='" + ontologyURI + "'");
+                if (rSet.next()) {
+                    String ontologyRowID = rSet.getString("id");
+                    String statementstr = "INSERT INTO " + resourcesTable
+                                          + " (id, resourceURI, resourcePath, resourceType) VALUES ("
+                                          + ontologyRowID + ", '" + individualURI + "', '" + individualPath
+                                          + "', '" + INDIVIDUAL_RESOURCE + "')";
+                    statement.executeUpdate(statementstr);
+                }
+                con.close();
+            }
+        } catch (Exception e) {
+            logger.error("Error ", e);
+        }
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @see
+     * 
+     * org.apache.stanbol.persistencestore.rest.IResourceManager#hasOntology (java.lang.String)
+     */
+    public boolean hasOntology(String ontologyURI) {
+        boolean result = ontologies.containsKey(ontologyURI);
+        return result;
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @seeeu.iksproject.fise.stores.persistencestore.rest.IResourceManager# getOntologyPath(java.lang.String)
+     */
+    public String getOntologyPath(String ontologyURI) {
+        String result = null;
+        if (ontologies.containsKey(ontologyURI)) {
+            result = ontologies.get(ontologyURI);
+        }
+        return result;
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @seeeu.iksproject.fise.stores.persistencestore.rest.IResourceManager#
+     * getOntologyFullPath(java.lang.String)
+     */
+    public String getOntologyFullPath(String ontologyURI) {
+        String result = null;
+        if (ontologies.containsKey(ontologyURI)) {
+            result = ontologyPathPrefix + ontologies.get(ontologyURI);
+        }
+        return result;
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @seeeu.iksproject.fise.stores.persistencestore.rest.IResourceManager#
+     * getResourceFullPath(java.lang.String)
+     */
+    public String getResourceFullPath(String resourceURI) {
+        String result = null;
+        String ontologyURI = resourceToOntologyURIs.get(resourceURI);
+        if (ontologies.containsKey(ontologyURI) && resources.containsKey(ontologyURI + "#" + resourceURI)) {
+            String resourceType = resourcesTypes.get(ontologyURI + "#" + resourceURI);
+            String pathPrefix = null;
+            if (resourceType.equalsIgnoreCase(CLASS_RESOURCE)) {
+                pathPrefix = classPathPrefix;
+            } else if (resourceType.equalsIgnoreCase(OBJECT_PROPERTY_RESOURCE)) {
+                pathPrefix = objectPropertyPathPrefix;
+            } else if (resourceType.equalsIgnoreCase(DATA_PROPERTY_RESOURCE)) {
+                pathPrefix = dataPropertyPathPrefix;
+            } else if (resourceType.equalsIgnoreCase(INDIVIDUAL_RESOURCE)) {
+                pathPrefix = individualPathPrefix;
+            }
+            result = ontologyPathPrefix + ontologies.get(ontologyURI) + "/" + pathPrefix
+                     + resources.get(ontologyURI + "#" + resourceURI);
+        }
+        return result;
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @seeeu.iksproject.fise.stores.persistencestore.rest.IResourceManager#
+     * getOntologyURIForPath(java.lang.String)
+     */
+    public String getOntologyURIForPath(String ontologyPath) {
+        String result = null;
+        if (ontologiesInverted.containsKey(ontologyPath)) {
+            result = ontologiesInverted.get(ontologyPath);
+        }
+        return result;
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @seeeu.iksproject.fise.stores.persistencestore.rest.IResourceManager#
+     * getResourceURIForPath(java.lang.String, java.lang.String)
+     */
+    public String getResourceURIForPath(String ontologyPath, String resourcePath) {
+        String result = null;
+        if (resourcesInverted.containsKey(ontologyPath + "#" + resourcePath)) {
+            result = resourcesInverted.get(ontologyPath + "#" + resourcePath);
+        }
+        return result;
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @seeeu.iksproject.fise.stores.persistencestore.rest.IResourceManager# getResourceType(java.lang.String)
+     */
+    public String getResourceType(String resourceURI) {
+        String result = resourcesTypes.get(resourceURI);
+        return result;
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @seeeu.iksproject.fise.stores.persistencestore.rest.IResourceManager# removeOntology(java.lang.String)
+     */
+    public void removeOntology(String ontologyURI) {
+        try {
+            // first clear hashtables
+            String ontologyPath = ontologies.get(ontologyURI);
+            if (ontologyPath == null) {
+                logger.warn("Ontology " + ontologyURI + " already deleted");
+                return;
+            }
+            ontologies.remove(ontologyURI);
+            ontologiesInverted.remove(ontologyPath);
+
+            List<String> keysToRemove = new Vector<String>();
+            Set<String> resources_keys = resources.keySet();
+            Iterator<String> resources_keys_itr = resources_keys.iterator();
+            while (resources_keys_itr.hasNext()) {
+                String key = resources_keys_itr.next();
+                if (key.startsWith(ontologyURI)) {
+                    keysToRemove.add(key);
+                }
+            }
+            Iterator<String> keysToRemoveItr = keysToRemove.iterator();
+            while (keysToRemoveItr.hasNext()) {
+                resources.remove(keysToRemoveItr.next());
+            }
+
+            keysToRemove = new Vector<String>();
+            Set<String> resourcesInverted_keys = resourcesInverted.keySet();
+            Iterator<String> resourcesInverted_keys_itr = resourcesInverted_keys.iterator();
+            while (resourcesInverted_keys_itr.hasNext()) {
+                String key = resourcesInverted_keys_itr.next();
+                if (key.startsWith(ontologyURI)) {
+                    keysToRemove.add(key);
+                }
+            }
+            keysToRemoveItr = keysToRemove.iterator();
+            while (keysToRemoveItr.hasNext()) {
+                resourcesInverted.remove(keysToRemoveItr.next());
+            }
+
+            keysToRemove = new Vector<String>();
+            Set<String> resourcesTypes_keys = resourcesTypes.keySet();
+            Iterator<String> resourcesTypes_keys_itr = resourcesTypes_keys.iterator();
+            while (resourcesTypes_keys_itr.hasNext()) {
+                String key = resourcesTypes_keys_itr.next();
+                if (key.startsWith(ontologyURI)) {
+                    keysToRemove.add(key);
+                }
+            }
+            keysToRemoveItr = keysToRemove.iterator();
+            while (keysToRemoveItr.hasNext()) {
+                resourcesTypes.remove(keysToRemoveItr.next());
+            }
+
+            keysToRemove = new Vector<String>();
+            Set<String> resourceToOntologyURIs_keys = resourceToOntologyURIs.keySet();
+            Iterator<String> resourceToOntologyURIs_keys_itr = resourceToOntologyURIs_keys.iterator();
+            while (resourceToOntologyURIs_keys_itr.hasNext()) {
+                String key = resourceToOntologyURIs_keys_itr.next();
+                String value = resourceToOntologyURIs.get(key);
+                if (value.equalsIgnoreCase(ontologyURI)) {
+                    keysToRemove.add(key);
+                }
+            }
+            keysToRemoveItr = keysToRemove.iterator();
+            while (keysToRemoveItr.hasNext()) {
+                resourceToOntologyURIs.remove(keysToRemoveItr.next());
+            }
+
+            // then clear database
+            Connection con = obtainConnection();
+            Statement statement = con.createStatement();
+            String sql = "SELECT id from " + ontologiesTable + " WHERE ontologyURI='" + ontologyURI + "'";
+            ResultSet rSet = statement.executeQuery(sql);
+            String id = null;
+            if (rSet.next()) {
+                id = rSet.getString("id");
+            }
+
+            statement = con.createStatement();
+            sql = "DELETE from " + ontologiesTable + " WHERE id=" + id;
+            statement.executeUpdate(sql);
+
+            statement = con.createStatement();
+            sql = "DELETE from " + resourcesTable + " WHERE id=" + id;
+            statement.executeUpdate(sql);
+
+            con.close();
+            // logger.info("Connection Closed");
+
+        } catch (Exception e) {
+            logger.error("Error ", e);
+        }
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @seeeu.iksproject.fise.stores.persistencestore.rest.IResourceManager# removeResource(java.lang.String)
+     */
+    public void removeResource(String resourceURI) {
+        try {
+            // first clear hashtables
+            String classPath = resources.get(resourceURI);
+            if (classPath == null) {
+                logger.warn("Resource" + resourceURI + "not found");
+                return;
+            }
+
+            String ontologyURI = resourceToOntologyURIs.get(resourceURI);
+            String ontologyPath = ontologies.get(ontologyURI);
+            resources.remove(ontologyURI + "#" + resourceURI);
+            resourcesInverted.remove(ontologyPath + "#" + classPath);
+            resourcesTypes.remove(ontologyURI + "#" + resourceURI);
+            resourceToOntologyURIs.remove(resourceURI);
+
+            // then clear database
+            Connection con = obtainConnection();
+            Statement statement = con.createStatement();
+            String sql = "DELETE from " + resourcesTable + " WHERE resourceURI='" + resourceURI + "'";
+            statement.executeUpdate(sql);
+            con.close();
+        } catch (Exception e) {
+            logger.error("Error ", e);
+        }
+    }
+
+    // FIXME:: make sure that this method returns the reference to the imported
+    // class!!!
+    /*
+     * (non-Javadoc)
+     * 
+     * @seeeu.iksproject.fise.stores.persistencestore.rest.IResourceManager#
+     * resolveOntologyURIFromResourceURI(java.lang.String)
+     */
+    public String resolveOntologyURIFromResourceURI(String resourceURI) {
+        String result = null;
+        if (resourceToOntologyURIs.containsKey(resourceURI)) {
+            result = resourceToOntologyURIs.get(resourceURI);
+        }
+        return result;
+    }
+
+    /*
+     * (non-Javadoc)
+     * 
+     * @seeeu.iksproject.fise.stores.persistencestore.rest.IResourceManager# clearResourceManager()
+     */
+    public void clearResourceManager() {
+        try {
+            // first clear hashtables
+            ontologies.clear();
+            ontologiesInverted.clear();
+            resources.clear();
+            resourcesInverted.clear();
+            resourcesTypes.clear();
+            resourceToOntologyURIs.clear();
+
+            // then clear database
+            Connection con = obtainConnection();
+            boolean ontologiesTableExists = checkTableExists(con, ontologiesTable);
+            boolean resourceTableExists = checkTableExists(con, resourcesTable);
+            Statement statement = con.createStatement();
+            if (ontologiesTableExists) {
+                String sql1 = "DELETE  FROM " + ontologiesTable;
+                statement.executeUpdate(sql1);
+            }
+            if (resourceTableExists) {
+                statement = con.createStatement();
+                String sql2 = "DELETE FROM " + resourcesTable;
+                statement.execute(sql2);
+            }
+            con.close();
+            logger.info("Connection Closed");
+        } catch (Exception e) {
+            logger.error("Error ", e);
+        }
+    }
+
+    public Connection obtainConnection() throws InstantiationException,
+                                        IllegalAccessException,
+                                        ClassNotFoundException,
+                                        SQLException {
+        return DriverManager.getConnection(DB_URL);// , DB_USER, DB_PW);
+    }
+
+    private String normalizeURI(String uri) {
+        // FIXME Find a solution to # problem
+        return uri.replace("#", "/");
+    }
+
+    @Override
+    public String convertEntityRelativePathToURI(String entityPath) {
+        return entityPath.substring(0, entityPath.lastIndexOf("/")) + "#"
+               + entityPath.substring(entityPath.lastIndexOf("/") + 1);
+    }
+}

Propchange: incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/ResourceManagerImp.java
------------------------------------------------------------------------------
    svn:executable = *

Added: incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/ServletRegisterer.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/ServletRegisterer.java?rev=1086954&view=auto
==============================================================================
--- incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/ServletRegisterer.java (added)
+++ incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/ServletRegisterer.java Wed Mar 30 13:43:53 2011
@@ -0,0 +1,120 @@
+package org.apache.stanbol.ontologymanager.store.rest;
+
+import java.util.Dictionary;
+import java.util.Hashtable;
+
+import javax.servlet.ServletContext;
+import javax.servlet.ServletException;
+
+import org.apache.felix.scr.annotations.Activate;
+import org.apache.felix.scr.annotations.Component;
+import org.apache.felix.scr.annotations.Deactivate;
+import org.apache.felix.scr.annotations.Property;
+import org.apache.felix.scr.annotations.Reference;
+import org.apache.stanbol.ontologymanager.store.api.PersistenceStore;
+import org.osgi.service.component.ComponentContext;
+import org.osgi.service.http.HttpService;
+import org.osgi.service.http.NamespaceException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.sun.jersey.spi.container.servlet.ServletContainer;
+
+@Component(immediate = true, metatype = true)
+public class ServletRegisterer {
+
+    private static Logger logger = LoggerFactory.getLogger(ServletRegisterer.class.getName());
+
+    @Property(value = "/ontologymanager/store")
+    private static final String ALIAS_PROP = "org.apache.stanbol.ontologymanager.store.rest.alias";
+
+    @Property(value = "/ontologymanager/store/static")
+    public static final String STATIC_RESOURCES_URL_ROOT_PROPERTY = "eu.iksproject.fise.jersey.static.url";
+
+    @Property(value = "/META-INF/static")
+    public static final String STATIC_RESOURCES_CLASSPATH_PROPERTY = "eu.iksproject.fise.jersey.static.classpath";
+
+    @Property(value = "/META-INF/templates")
+    public static final String FREEMARKER_TEMPLATE_CLASSPATH_PROPERTY = "eu.iksproject.fise.jersey.templates.classpath";
+
+    private String alias;
+
+    @Reference
+    private PersistenceStore persistenceStore;
+
+    @Reference
+    private HttpService httpService;
+
+    protected ServletContext servletContext;
+
+    public ServletRegisterer() {}
+
+    @Activate
+    public void activate(ComponentContext cc) {
+
+        this.alias = (String) cc.getProperties().get(ALIAS_PROP);
+        String staticUrlRoot = (String) cc.getProperties().get(STATIC_RESOURCES_URL_ROOT_PROPERTY);
+        String staticClasspath = (String) cc.getProperties().get(STATIC_RESOURCES_CLASSPATH_PROPERTY);
+        String freemakerTemplates = (String) cc.getProperties().get(FREEMARKER_TEMPLATE_CLASSPATH_PROPERTY);
+        ServletContainer container = new ServletContainer();
+        ClassLoader ctc = Thread.currentThread().getContextClassLoader();
+        Thread.currentThread().setContextClassLoader(ServletRegisterer.class.getClassLoader());
+        try {
+            httpService.registerServlet(alias, container, getInitParams(), null);
+            httpService.registerResources(staticUrlRoot, staticClasspath, null);
+        } catch (ServletException e) {
+            throw new RuntimeException("Servlet Registration Failed", e);
+        } catch (NamespaceException e) {
+            throw new RuntimeException("Namespace exception", e);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        } finally {
+            Thread.currentThread().setContextClassLoader(ctc);
+        }
+        servletContext = container.getServletContext();
+        servletContext.setAttribute(PersistenceStore.class.getName(), persistenceStore);
+        servletContext.setAttribute(STATIC_RESOURCES_URL_ROOT_PROPERTY, staticUrlRoot);
+        servletContext.setAttribute(FreemarkerViewProcessor.FREEMARKER_TEMPLATE_PATH_INIT_PARAM,
+            freemakerTemplates);
+        logger.info("Registered resources");
+
+    }
+
+    @Deactivate
+    public void deactive() {
+        httpService.unregister(alias);
+        servletContext = null;
+    }
+
+    public Dictionary<String,String> getInitParams() {
+        Dictionary<String,String> initParams = new Hashtable<String,String>();
+        initParams.put("javax.ws.rs.Application", JerseyApplication.class.getName());
+        initParams.put("com.sun.jersey.config.feature.ImplicitViewables", "true");
+        initParams.put("com.sun.jersey.spi.container.ContainerRequestFilters",
+            "com.sun.jersey.api.container.filter.PostReplaceFilter");
+
+        return initParams;
+    }
+
+    public void bindPersistenceStore(PersistenceStore persistenceStore) {
+        this.persistenceStore = persistenceStore;
+        if (servletContext != null) {
+            servletContext.setAttribute(PersistenceStore.class.getName(), persistenceStore);
+        }
+    }
+
+    public void unbindPersistenceStore(PersistenceStore persistenceStore) {
+        this.persistenceStore = null;
+        if (servletContext != null) {
+            servletContext.setAttribute(PersistenceStore.class.getName(), null);
+        }
+    }
+
+    public void bindHttpService(HttpService httpService) {
+        this.httpService = httpService;
+    }
+
+    public void unbindHttpService(HttpService httpService) {
+        this.httpService = null;
+    }
+}

Propchange: incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/ServletRegisterer.java
------------------------------------------------------------------------------
    svn:executable = *

Added: incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/resources/Ontologies.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/resources/Ontologies.java?rev=1086954&view=auto
==============================================================================
--- incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/resources/Ontologies.java (added)
+++ incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/resources/Ontologies.java Wed Mar 30 13:43:53 2011
@@ -0,0 +1,151 @@
+package org.apache.stanbol.ontologymanager.store.rest.resources;
+
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.servlet.ServletContext;
+import javax.ws.rs.Consumes;
+import javax.ws.rs.DELETE;
+import javax.ws.rs.FormParam;
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.Produces;
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.Status;
+import javax.ws.rs.core.UriInfo;
+
+import org.apache.stanbol.ontologymanager.store.api.LockManager;
+import org.apache.stanbol.ontologymanager.store.api.PersistenceStore;
+import org.apache.stanbol.ontologymanager.store.api.ResourceManager;
+import org.apache.stanbol.ontologymanager.store.model.AdministeredOntologies;
+import org.apache.stanbol.ontologymanager.store.model.OntologyMetaInformation;
+import org.apache.stanbol.ontologymanager.store.rest.LockManagerImp;
+import org.apache.stanbol.ontologymanager.store.rest.ResourceManagerImp;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.sun.jersey.api.view.ImplicitProduces;
+import com.sun.jersey.api.view.Viewable;
+
+//The Java class will be hosted at the URI path "/ontologies"
+//@Component
+//@Service(value = Object.class)
+//@Property(name = "javax.ws.rs", boolValue = true)
+@Path("/ontologies")
+@ImplicitProduces(MediaType.TEXT_HTML + ";qs=2.0")
+public class Ontologies {
+    private static final Logger logger = LoggerFactory.getLogger(Ontologies.class);
+
+    private static final String VIEWABLE_PATH = "/org/apache/stanbol/ontologymanager/store/rest/resources/ontologies";
+
+    private PersistenceStore persistenceStore;
+
+    public Ontologies(@Context ServletContext context) {
+        this.persistenceStore = (PersistenceStore) context.getAttribute(PersistenceStore.class.getName());
+    }
+
+    @GET
+    @Produces(MediaType.APPLICATION_XML)
+    public Response getClichedMessage() {
+        LockManager lockManager = LockManagerImp.getInstance();
+        lockManager.obtainReadLockFor(LockManagerImp.GLOBAL_SPACE);
+        Response response = null;
+        try {
+            AdministeredOntologies administeredOntologies = persistenceStore.retrieveAdministeredOntologies();
+            response = Response.ok(administeredOntologies, MediaType.APPLICATION_XML_TYPE).build();
+        } catch (Exception e) {
+            throw new WebApplicationException(Response.Status.INTERNAL_SERVER_ERROR);
+        } finally {
+            lockManager.releaseReadLockFor(LockManagerImp.GLOBAL_SPACE);
+        }
+        return response;
+    }
+
+    // The Java method will process HTTP POST requests
+    @POST
+    // The Java method will accept content identified by the MIME Media
+    // type "application/x-www-form-urlencoded"
+    @Consumes("application/x-www-form-urlencoded")
+    @Produces(MediaType.APPLICATION_XML)
+    public Response saveOntology(@FormParam("ontologyURI") String ontologyURI,
+                                 @FormParam("ontologyContent") String ontologyContent) {
+        Response response = null;
+        LockManager lockManager = LockManagerImp.getInstance();
+        lockManager.obtainReadLockFor(LockManagerImp.GLOBAL_SPACE);
+        lockManager.obtainWriteLockFor(ontologyURI);
+        try {
+            OntologyMetaInformation ontologyMetaInformation = persistenceStore.saveOntology(ontologyContent,
+                ontologyURI, "UTF-8");
+            response = Response.ok(ontologyMetaInformation, MediaType.APPLICATION_XML_TYPE).build();
+        } catch (Exception e) {
+            logger.error("Error ", e);
+            throw new WebApplicationException(Response.Status.INTERNAL_SERVER_ERROR);
+        } finally {
+            lockManager.releaseReadLockFor(LockManagerImp.GLOBAL_SPACE);
+            lockManager.releaseWriteLockFor(ontologyURI);
+        }
+        return response;
+    }
+
+    // The Java method will process HTTP DELETE requests
+    @DELETE
+    public void delete() {
+        LockManager lockManager = LockManagerImp.getInstance();
+        lockManager.obtainWriteLockFor(LockManagerImp.GLOBAL_SPACE);
+        try {
+
+            persistenceStore.clearPersistenceStore();
+            ResourceManager resourceManager = ResourceManagerImp.getInstance();
+            resourceManager.clearResourceManager();
+        } catch (Exception e) {
+            logger.error("Error ", e);
+            throw new WebApplicationException(Response.Status.INTERNAL_SERVER_ERROR);
+        } finally {
+            lockManager.releaseWriteLockFor(LockManagerImp.GLOBAL_SPACE);
+        }
+    }
+
+    // Methods for HTML View
+
+    @GET
+    @Produces(MediaType.TEXT_HTML)
+    public Viewable getViewable(@Context UriInfo uriInfo) {
+        return new Viewable(VIEWABLE_PATH, this);
+    }
+
+    @POST
+    @Consumes(MediaType.APPLICATION_FORM_URLENCODED)
+    @Produces(MediaType.TEXT_HTML)
+    public Response createAndRedirect(@FormParam("ontologyURI") String ontologyURI,
+                                      @FormParam("ontologyContent") String ontologyContent) {
+        Response response = this.saveOntology(ontologyURI, ontologyContent);
+        OntologyMetaInformation ont = ((OntologyMetaInformation) response.getEntity());
+        try {
+            return Response.seeOther(URI.create(ont.getHref())).type(MediaType.TEXT_HTML).header("Accept", MediaType.TEXT_HTML).build();
+        } catch (Exception e) {
+            logger.error("Error ", e);
+            throw new WebApplicationException(Status.INTERNAL_SERVER_ERROR);
+        }
+
+    }
+
+    public List<OntologyMetaInformation> getOntologies() {
+        LockManager lockManager = LockManagerImp.getInstance();
+        lockManager.obtainReadLockFor(LockManagerImp.GLOBAL_SPACE);
+        List<OntologyMetaInformation> onts = new ArrayList<OntologyMetaInformation>();
+        try {
+            onts = persistenceStore.retrieveAdministeredOntologies().getOntologyMetaInformation();
+        } catch (Exception e) {
+            logger.error("Error ", e);
+            throw new RuntimeException(e);
+        } finally {
+            lockManager.releaseReadLockFor(LockManagerImp.GLOBAL_SPACE);
+        }
+        return onts;
+    }
+}

Propchange: incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/resources/Ontologies.java
------------------------------------------------------------------------------
    svn:executable = *

Added: incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/resources/OntologyClasses.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/resources/OntologyClasses.java?rev=1086954&view=auto
==============================================================================
--- incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/resources/OntologyClasses.java (added)
+++ incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/resources/OntologyClasses.java Wed Mar 30 13:43:53 2011
@@ -0,0 +1,138 @@
+package org.apache.stanbol.ontologymanager.store.rest.resources;
+
+import java.net.URI;
+
+import javax.servlet.ServletContext;
+import javax.ws.rs.Consumes;
+import javax.ws.rs.FormParam;
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.Status;
+
+import org.apache.stanbol.ontologymanager.store.api.LockManager;
+import org.apache.stanbol.ontologymanager.store.api.PersistenceStore;
+import org.apache.stanbol.ontologymanager.store.api.ResourceManager;
+import org.apache.stanbol.ontologymanager.store.model.ClassMetaInformation;
+import org.apache.stanbol.ontologymanager.store.model.ClassesForOntology;
+import org.apache.stanbol.ontologymanager.store.rest.LockManagerImp;
+import org.apache.stanbol.ontologymanager.store.rest.ResourceManagerImp;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.sun.jersey.api.view.ImplicitProduces;
+import com.sun.jersey.api.view.Viewable;
+
+//@Component
+//@Service(value = Object.class)
+//@Property(name = "javax.ws.rs", boolValue = true)
+@Path("/ontologies/{ontologyPath:.+}/classes/")
+@ImplicitProduces(MediaType.TEXT_HTML + ";qs=2.0")
+public class OntologyClasses {
+    private static final Logger logger = LoggerFactory.getLogger(OntologyClasses.class);
+
+    private static final String VIEWABLE_PATH = "/org/apache/stanbol/ontologymanager/store/rest/resources/ontologyClasses";
+
+    private PersistenceStore persistenceStore;
+
+    // HTML View Variable
+    private ClassesForOntology metadata;
+
+    public OntologyClasses(@Context ServletContext context) {
+        this.persistenceStore = (PersistenceStore) context.getAttribute(PersistenceStore.class.getName());
+    }
+
+    // The Java method will process HTTP GET requests
+    @GET
+    // The Java method will produce content identified by the MIME Media
+    // type "text/plain"
+    @Produces("application/xml")
+    public Response retrieveOntologyClasses(@PathParam("ontologyPath") String ontologyPath) {
+        Response response = null;
+        LockManager lockManager = LockManagerImp.getInstance();
+        lockManager.obtainReadLockFor(ontologyPath);
+        try {
+
+            ResourceManager resourceManager = ResourceManagerImp.getInstance();
+            String ontologyURI = resourceManager.getOntologyURIForPath(ontologyPath);
+            if (ontologyURI == null) {
+                throw new WebApplicationException(Response.Status.NOT_FOUND);
+            }
+            try {
+                ClassesForOntology classesForOntology = persistenceStore
+                        .retrieveClassesOfOntology(ontologyURI);
+                response = Response.ok(classesForOntology, MediaType.APPLICATION_XML_TYPE).build();
+            } catch (Exception e) {
+                logger.error("Error ", e);
+                throw new WebApplicationException(Response.Status.INTERNAL_SERVER_ERROR);
+            }
+        } finally {
+            lockManager.releaseReadLockFor(ontologyPath);
+        }
+        return response;
+    }
+
+    // The Java method will process HTTP POST requests
+    @POST
+    // The Java method will accept content identified by the MIME Media
+    // type "application/x-www-form-urlencoded"
+    @Produces(MediaType.APPLICATION_XML)
+    @Consumes("application/x-www-form-urlencoded")
+    public Response generateClass(@PathParam("ontologyPath") String ontologyPath,
+                                  @FormParam("classURI") String classURI) {
+        Response response = null;
+        LockManager lockManager = LockManagerImp.getInstance();
+        lockManager.obtainWriteLockFor(ontologyPath);
+        try {
+            ResourceManager resourceManager = ResourceManagerImp.getInstance();
+            String ontologyURI = resourceManager.getOntologyURIForPath(ontologyPath);
+            if (ontologyURI == null) {
+                throw new WebApplicationException(Response.Status.NOT_FOUND);
+            }
+            try {
+                ClassMetaInformation classMetaInformation = persistenceStore.generateClassForOntology(
+                    ontologyURI, classURI);
+                response = Response.ok(classMetaInformation, MediaType.APPLICATION_XML_TYPE).build();
+            } catch (Exception e) {
+                logger.error("Error ", e);
+                throw new WebApplicationException(Response.Status.INTERNAL_SERVER_ERROR);
+            }
+        } finally {
+            lockManager.releaseWriteLockFor(ontologyPath);
+        }
+        return response;
+    }
+
+    // HTML View Methods
+    @GET
+    @Produces(MediaType.TEXT_HTML)
+    public Viewable getViewable(@PathParam("ontologyPath") String ontologyPath) {
+        this.metadata = ((ClassesForOntology) this.retrieveOntologyClasses(ontologyPath).getEntity());
+        return new Viewable(VIEWABLE_PATH, this);
+    }
+
+    @POST
+    @Produces(MediaType.TEXT_HTML)
+    @Consumes(MediaType.APPLICATION_FORM_URLENCODED)
+    public Response createAndRedirect(@PathParam("ontologyPath") String ontologyPath,
+                                      @FormParam("classURI") String classURI) {
+        Response response = this.generateClass(ontologyPath, classURI);
+        ClassMetaInformation cmi = (ClassMetaInformation) response.getEntity();
+        try {
+            return Response.seeOther(URI.create(cmi.getHref())).build();
+        } catch (Exception e) {
+            throw new WebApplicationException(Status.INTERNAL_SERVER_ERROR);
+        }
+    }
+
+    public ClassesForOntology getMetadata() {
+        return metadata;
+    }
+
+}

Propchange: incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/resources/OntologyClasses.java
------------------------------------------------------------------------------
    svn:executable = *

Added: incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/resources/OntologyDatatypeProperties.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/resources/OntologyDatatypeProperties.java?rev=1086954&view=auto
==============================================================================
--- incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/resources/OntologyDatatypeProperties.java (added)
+++ incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/resources/OntologyDatatypeProperties.java Wed Mar 30 13:43:53 2011
@@ -0,0 +1,140 @@
+package org.apache.stanbol.ontologymanager.store.rest.resources;
+
+import java.net.URI;
+
+import javax.servlet.ServletContext;
+import javax.ws.rs.Consumes;
+import javax.ws.rs.FormParam;
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.Status;
+
+import org.apache.stanbol.ontologymanager.store.api.LockManager;
+import org.apache.stanbol.ontologymanager.store.api.PersistenceStore;
+import org.apache.stanbol.ontologymanager.store.api.ResourceManager;
+import org.apache.stanbol.ontologymanager.store.model.DatatypePropertiesForOntology;
+import org.apache.stanbol.ontologymanager.store.model.PropertyMetaInformation;
+import org.apache.stanbol.ontologymanager.store.rest.LockManagerImp;
+import org.apache.stanbol.ontologymanager.store.rest.ResourceManagerImp;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.sun.jersey.api.view.ImplicitProduces;
+import com.sun.jersey.api.view.Viewable;
+
+//@Component
+//@Service(value = Object.class)
+//@Property(name = "javax.ws.rs", boolValue = true)
+@Path("/ontologies/{ontologyPath:.+}/datatypeProperties")
+@ImplicitProduces(MediaType.TEXT_HTML + ";qs=2.0")
+public class OntologyDatatypeProperties {
+    private static final Logger logger = LoggerFactory.getLogger(OntologyDatatypeProperties.class);
+    private static final String VIEWABLE_PATH = "/org/apache/stanbol/ontologymanager/store/rest/resources/ontologyDatatypeProperties";
+
+    private PersistenceStore persistenceStore;
+
+    // HTML View Variables
+    private DatatypePropertiesForOntology metadata;
+
+    public OntologyDatatypeProperties(@Context ServletContext context) {
+        this.persistenceStore = (PersistenceStore) context.getAttribute(PersistenceStore.class.getName());
+    }
+
+    // The Java method will process HTTP GET requests
+    @GET
+    // The Java method will produce content identified by the MIME Media
+    // type "text/plain"
+    @Produces("application/xml")
+    public Response retrieveOntologyDatatypeProperties(@PathParam("ontologyPath") String ontologyPath) {
+        Response response = null;
+        LockManager lockManager = LockManagerImp.getInstance();
+        lockManager.obtainReadLockFor(ontologyPath);
+        try {
+            ResourceManager resourceManager = ResourceManagerImp.getInstance();
+            String ontologyURI = resourceManager.getOntologyURIForPath(ontologyPath);
+            if (ontologyURI == null) {
+                throw new WebApplicationException(Response.Status.NOT_FOUND);
+            }
+            try {
+                DatatypePropertiesForOntology datatypePropertiesForOntology = persistenceStore
+                        .retrieveDatatypePropertiesOfOntology(ontologyURI);
+                response = Response.ok(datatypePropertiesForOntology, MediaType.APPLICATION_XML_TYPE).build();
+            } catch (Exception e) {
+                logger.error("Error ", e);
+                throw new WebApplicationException(Response.Status.INTERNAL_SERVER_ERROR);
+            }
+        } finally {
+            lockManager.releaseReadLockFor(ontologyPath);
+        }
+        return response;
+    }
+
+    // The Java method will process HTTP POST requests
+    @POST
+    // The Java method will accept content identified by the MIME Media
+    // type "application/x-www-form-urlencoded"
+    @Produces(MediaType.APPLICATION_XML)
+    @Consumes("application/x-www-form-urlencoded")
+    public Response generateDatatypeProperty(@PathParam("ontologyPath") String ontologyPath,
+                                             @FormParam("datatypePropertyURI") String datatypePropertyURI) {
+        Response response = null;
+        LockManager lockManager = LockManagerImp.getInstance();
+        lockManager.obtainWriteLockFor(ontologyPath);
+        try {
+
+            ResourceManager resourceManager = ResourceManagerImp.getInstance();
+            String ontologyURI = resourceManager.getOntologyURIForPath(ontologyPath);
+            if (ontologyURI == null) {
+                throw new WebApplicationException(Response.Status.NOT_FOUND);
+            }
+            try {
+                PropertyMetaInformation datatypePropertyMetaInformation = persistenceStore
+                        .generateDatatypePropertyForOntology(ontologyURI, datatypePropertyURI);
+                response = Response.ok(datatypePropertyMetaInformation, MediaType.APPLICATION_XML_TYPE)
+                        .build();
+
+            } catch (Exception e) {
+                logger.error("Error ", e);
+                throw new WebApplicationException(Response.Status.INTERNAL_SERVER_ERROR);
+            }
+        } finally {
+            lockManager.releaseWriteLockFor(ontologyPath);
+        }
+        return response;
+    }
+
+    // HTML View Methods
+    public DatatypePropertiesForOntology getMetadata() {
+        return metadata;
+    }
+
+    @GET
+    @Produces(MediaType.TEXT_HTML)
+    public Viewable getViewable(@PathParam("ontologyPath") String ontologyPath) {
+        Response response = retrieveOntologyDatatypeProperties(ontologyPath);
+        metadata = (DatatypePropertiesForOntology) response.getEntity();
+        return new Viewable(VIEWABLE_PATH, this);
+    }
+
+    @POST
+    @Produces(MediaType.TEXT_HTML)
+    @Consumes(MediaType.APPLICATION_FORM_URLENCODED)
+    public Response createAndRedirect(@PathParam("ontologyPath") String ontologyPath,
+                                      @FormParam("datatypePropertyURI") String datatypePropertyURI) {
+        Response response = this.generateDatatypeProperty(ontologyPath, datatypePropertyURI);
+        PropertyMetaInformation pmi = (PropertyMetaInformation) response.getEntity();
+        try {
+            return Response.seeOther(URI.create(pmi.getHref())).build();
+        } catch (Exception e) {
+            throw new WebApplicationException(Status.INTERNAL_SERVER_ERROR);
+        }
+
+    }
+}

Propchange: incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/resources/OntologyDatatypeProperties.java
------------------------------------------------------------------------------
    svn:executable = *

Added: incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/resources/OntologyDump.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/resources/OntologyDump.java?rev=1086954&view=auto
==============================================================================
--- incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/resources/OntologyDump.java (added)
+++ incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/resources/OntologyDump.java Wed Mar 30 13:43:53 2011
@@ -0,0 +1,50 @@
+package org.apache.stanbol.ontologymanager.store.rest.resources;
+
+import javax.servlet.ServletContext;
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
+import javax.ws.rs.QueryParam;
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.Status;
+
+import org.apache.stanbol.ontologymanager.store.api.PersistenceStore;
+import org.apache.stanbol.ontologymanager.store.api.ResourceManager;
+import org.apache.stanbol.ontologymanager.store.rest.ResourceManagerImp;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+//@Component
+//@Service(value = Object.class)
+//@Property(name = "javax.ws.rs", boolValue = true)
+@Path("/ontologies/{ontologyPath:.+}/dump")
+public class OntologyDump {
+    private static final Logger logger = LoggerFactory.getLogger(OntologyDump.class);
+    private PersistenceStore persistenceStore;
+
+    public OntologyDump(@Context ServletContext context) {
+        this.persistenceStore = (PersistenceStore) context.getAttribute(PersistenceStore.class.getName());
+    }
+
+    @GET
+    @Produces("application/xml")
+    public String dumpOntology(@PathParam("ontologyPath") String ontologyPath,
+                               @QueryParam(value = "infer") boolean infer) {
+        String result = null;
+        try {
+            ResourceManager resourceManager = ResourceManagerImp.getInstance();
+            String ontologyURI = resourceManager.getOntologyURIForPath(ontologyPath);
+            result = persistenceStore.retrieveOntology(ontologyURI, "RDF/XML", infer);
+        } catch (Exception e) {
+            logger.error("Error ", e);
+            throw new WebApplicationException(Response.Status.INTERNAL_SERVER_ERROR);
+        }
+        if (result == null) {
+            throw new WebApplicationException(Status.NOT_FOUND);
+        }
+        return result;
+    }
+}

Propchange: incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/resources/OntologyDump.java
------------------------------------------------------------------------------
    svn:executable = *

Added: incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/resources/OntologyIndividuals.java
URL: http://svn.apache.org/viewvc/incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/resources/OntologyIndividuals.java?rev=1086954&view=auto
==============================================================================
--- incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/resources/OntologyIndividuals.java (added)
+++ incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/resources/OntologyIndividuals.java Wed Mar 30 13:43:53 2011
@@ -0,0 +1,140 @@
+package org.apache.stanbol.ontologymanager.store.rest.resources;
+
+import java.net.URI;
+
+import javax.servlet.ServletContext;
+import javax.ws.rs.Consumes;
+import javax.ws.rs.FormParam;
+import javax.ws.rs.GET;
+import javax.ws.rs.POST;
+import javax.ws.rs.Path;
+import javax.ws.rs.PathParam;
+import javax.ws.rs.Produces;
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.Status;
+
+import org.apache.stanbol.ontologymanager.store.api.LockManager;
+import org.apache.stanbol.ontologymanager.store.api.PersistenceStore;
+import org.apache.stanbol.ontologymanager.store.api.ResourceManager;
+import org.apache.stanbol.ontologymanager.store.model.IndividualMetaInformation;
+import org.apache.stanbol.ontologymanager.store.model.IndividualsForOntology;
+import org.apache.stanbol.ontologymanager.store.rest.LockManagerImp;
+import org.apache.stanbol.ontologymanager.store.rest.ResourceManagerImp;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.sun.jersey.api.view.ImplicitProduces;
+import com.sun.jersey.api.view.Viewable;
+
+//@Component
+//@Service(value = Object.class)
+//@Property(name = "javax.ws.rs", boolValue = true)
+@Path("/ontologies/{ontologyPath:.+}/individuals")
+@ImplicitProduces(MediaType.TEXT_HTML + ";qs=2.0")
+public class OntologyIndividuals {
+    private static final Logger logger = LoggerFactory.getLogger(OntologyIndividuals.class);
+    public static final String VIEWABLE_PATH = "/org/apache/stanbol/ontologymanager/store/rest/resources/ontologyIndividuals";
+
+    private PersistenceStore persistenceStore;
+
+    // HTML Variable
+    private IndividualsForOntology metadata;
+
+    public OntologyIndividuals(@Context ServletContext context) {
+        this.persistenceStore = (PersistenceStore) context.getAttribute(PersistenceStore.class.getName());
+    }
+
+    // The Java method will process HTTP GET requests
+    @GET
+    // The Java method will produce content identified by the MIME Media
+    // type "text/plain"
+    @Produces("application/xml")
+    public Response retrieveOntologyIndividuals(@PathParam("ontologyPath") String ontologyPath) {
+        Response response = null;
+        LockManager lockManager = LockManagerImp.getInstance();
+        lockManager.obtainReadLockFor(ontologyPath);
+        try {
+
+            ResourceManager resourceManager = ResourceManagerImp.getInstance();
+            String ontologyURI = resourceManager.getOntologyURIForPath(ontologyPath);
+            if (ontologyURI == null) {
+                throw new WebApplicationException(Response.Status.NOT_FOUND);
+            }
+            try {
+                IndividualsForOntology individualsForOntology = persistenceStore
+                        .retrieveIndividualsOfOntology(ontologyURI);
+                response = Response.ok(individualsForOntology, MediaType.APPLICATION_XML_TYPE).build();
+            } catch (Exception e) {
+                logger.error("Error ", e);
+                throw new WebApplicationException(Response.Status.INTERNAL_SERVER_ERROR);
+            }
+        } finally {
+            lockManager.releaseReadLockFor(ontologyPath);
+        }
+        return response;
+    }
+
+    // The Java method will process HTTP POST requests
+    @POST
+    // The Java method will accept content identified by the MIME Media
+    // type "application/x-www-form-urlencoded"
+    @Produces(MediaType.APPLICATION_XML)
+    @Consumes("application/x-www-form-urlencoded")
+    public Response generateIndividual(@PathParam("ontologyPath") String ontologyPath,
+                                       @FormParam("classURI") String classURI,
+                                       @FormParam("individualURI") String individualURI) {
+        Response response = null;
+        LockManager lockManager = LockManagerImp.getInstance();
+        lockManager.obtainWriteLockFor(ontologyPath);
+        try {
+
+            ResourceManager resourceManager = ResourceManagerImp.getInstance();
+            String ontologyURI = resourceManager.getOntologyURIForPath(ontologyPath);
+            if (ontologyURI == null) {
+                throw new WebApplicationException(Response.Status.NOT_FOUND);
+            }
+            try {
+                IndividualMetaInformation individualMetaInformation = persistenceStore
+                        .generateIndividualForOntology(ontologyURI, classURI, individualURI);
+                response = Response.ok(individualMetaInformation, MediaType.APPLICATION_XML_TYPE).build();
+            } catch (Exception e) {
+                logger.error("Error ", e);
+                throw new WebApplicationException(Response.Status.INTERNAL_SERVER_ERROR);
+            }
+        } finally {
+            lockManager.releaseWriteLockFor(ontologyPath);
+        }
+        return response;
+    }
+
+    // HTML View Methods
+    public IndividualsForOntology getMetadata() {
+        return metadata;
+    }
+
+    @GET
+    @Produces(MediaType.TEXT_HTML)
+    public Viewable getViewable(@PathParam("ontologyPath") String ontologyPath) {
+        Response response = retrieveOntologyIndividuals(ontologyPath);
+        metadata = (IndividualsForOntology) response.getEntity();
+        return new Viewable(VIEWABLE_PATH, this);
+    }
+
+    @POST
+    @Consumes(MediaType.APPLICATION_FORM_URLENCODED)
+    @Produces(MediaType.TEXT_HTML)
+    public Response createAndRedirect(@PathParam("ontologyPath") String ontologyPath,
+                                      @FormParam("classURI") String classURI,
+                                      @FormParam("individualURI") String individualURI) {
+        Response response = generateIndividual(ontologyPath, classURI, individualURI);
+        IndividualMetaInformation imi = (IndividualMetaInformation) response.getEntity();
+        try {
+            return Response.seeOther(URI.create(imi.getHref())).build();
+        } catch (Exception e) {
+            throw new WebApplicationException(Status.INTERNAL_SERVER_ERROR);
+        }
+    }
+}

Propchange: incubator/stanbol/trunk/kres/ontologymanager/store/rest/src/main/java/org/apache/stanbol/ontologymanager/store/rest/resources/OntologyIndividuals.java
------------------------------------------------------------------------------
    svn:executable = *