You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@clerezza.apache.org by ha...@apache.org on 2019/02/03 17:37:25 UTC
[clerezza] branch reunited updated (01dc25b -> 50211e4)
This is an automated email from the ASF dual-hosted git repository.
hasan pushed a change to branch reunited
in repository https://gitbox.apache.org/repos/asf/clerezza.git.
from 01dc25b CLEREZZA-1026: Move some tests from rdf.core to api.impl
new ec0265f CLEREZZA-1026: Update version in sparql module
new 50211e4 CLEREZZA-1031: Move rdf.core access to a new module called dataset
The 2 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
{sparql => dataset}/pom.xml | 71 +++++++------------
.../dataset}/EntityAlreadyExistsException.java | 4 +-
.../dataset}/EntityUndeletableException.java | 4 +-
.../dataset}/ImmutableGraphServiceFactory.java | 10 +--
.../clerezza/dataset}/MGraphServiceFactory.java | 8 +--
.../clerezza/dataset}/NoSuchEntityException.java | 4 +-
.../clerezza/dataset}/QueryableTcProvider.java | 6 +-
.../org/apache/clerezza/dataset}/SecuredGraph.java | 21 ++----
.../org/apache/clerezza/dataset}/TcManager.java | 79 +++++++++------------
.../org/apache/clerezza/dataset}/TcProvider.java | 36 +++++-----
.../clerezza/dataset}/TcProviderMultiplexer.java | 29 +++-----
.../dataset}/WeightedProviderComparator.java | 2 +-
.../clerezza/dataset}/WeightedTcProvider.java | 36 +++++-----
.../java/org/apache/clerezza/dataset}/package.html | 48 ++++++-------
.../dataset}/security/TcAccessController.java | 30 +++-----
.../clerezza/dataset}/security/TcPermission.java | 2 +-
.../org/apache/clerezza/dataset}/SecurityTest.java | 39 +++++------
.../apache/clerezza/dataset}/TcManagerTest.java | 81 +++++++++++-----------
.../clerezza/dataset}/providers/WeightedA.java | 22 +++---
.../clerezza/dataset}/providers/WeightedA1.java | 23 +++---
.../dataset}/providers/WeightedAHeavy.java | 24 +++----
.../dataset}/providers/WeightedBlight.java | 23 +++---
.../clerezza/dataset}/providers/WeightedDummy.java | 23 +++---
sparql/pom.xml | 2 +-
24 files changed, 275 insertions(+), 352 deletions(-)
copy {sparql => dataset}/pom.xml (67%)
copy {rdf/core/src/main/java/org/apache/clerezza/rdf/core/access => dataset/src/main/java/org/apache/clerezza/dataset}/EntityAlreadyExistsException.java (94%)
copy {rdf/core/src/main/java/org/apache/clerezza/rdf/core/access => dataset/src/main/java/org/apache/clerezza/dataset}/EntityUndeletableException.java (94%)
copy {rdf/core/src/main/java/org/apache/clerezza/rdf/core/access => dataset/src/main/java/org/apache/clerezza/dataset}/ImmutableGraphServiceFactory.java (87%)
copy {rdf/core/src/main/java/org/apache/clerezza/rdf/core/access => dataset/src/main/java/org/apache/clerezza/dataset}/MGraphServiceFactory.java (88%)
copy {rdf/core/src/main/java/org/apache/clerezza/rdf/core/access => dataset/src/main/java/org/apache/clerezza/dataset}/NoSuchEntityException.java (94%)
copy {rdf/core/src/main/java/org/apache/clerezza/rdf/core/access => dataset/src/main/java/org/apache/clerezza/dataset}/QueryableTcProvider.java (88%)
copy {rdf/core/src/main/java/org/apache/clerezza/rdf/core/access => dataset/src/main/java/org/apache/clerezza/dataset}/SecuredGraph.java (85%)
copy {rdf/core/src/main/java/org/apache/clerezza/rdf/core/access => dataset/src/main/java/org/apache/clerezza/dataset}/TcManager.java (93%)
copy {rdf/core/src/main/java/org/apache/clerezza/rdf/core/access => dataset/src/main/java/org/apache/clerezza/dataset}/TcProvider.java (94%)
copy {rdf/core/src/main/java/org/apache/clerezza/rdf/core/access => dataset/src/main/java/org/apache/clerezza/dataset}/TcProviderMultiplexer.java (96%)
copy {rdf/core/src/main/java/org/apache/clerezza/rdf/core/access => dataset/src/main/java/org/apache/clerezza/dataset}/WeightedProviderComparator.java (96%)
copy {rdf/core/src/main/java/org/apache/clerezza/rdf/core/access => dataset/src/main/java/org/apache/clerezza/dataset}/WeightedTcProvider.java (95%)
copy {rdf/core/src/main/java/org/apache/clerezza/rdf/core/access => dataset/src/main/java/org/apache/clerezza/dataset}/package.html (80%)
copy {rdf/core/src/main/java/org/apache/clerezza/rdf/core/access => dataset/src/main/java/org/apache/clerezza/dataset}/security/TcAccessController.java (94%)
copy {rdf/core/src/main/java/org/apache/clerezza/rdf/core/access => dataset/src/main/java/org/apache/clerezza/dataset}/security/TcPermission.java (98%)
copy {rdf/core/src/test/java/org/apache/clerezza/rdf/core/access => dataset/src/test/java/org/apache/clerezza/dataset}/SecurityTest.java (86%)
copy {rdf/core/src/test/java/org/apache/clerezza/rdf/core/access => dataset/src/test/java/org/apache/clerezza/dataset}/TcManagerTest.java (80%)
copy {rdf/core/src/test/java/org/apache/clerezza/rdf/core/access => dataset/src/test/java/org/apache/clerezza/dataset}/providers/WeightedA.java (82%)
copy {rdf/core/src/test/java/org/apache/clerezza/rdf/core/access => dataset/src/test/java/org/apache/clerezza/dataset}/providers/WeightedA1.java (81%)
copy {rdf/core/src/test/java/org/apache/clerezza/rdf/core/access => dataset/src/test/java/org/apache/clerezza/dataset}/providers/WeightedAHeavy.java (79%)
copy {rdf/core/src/test/java/org/apache/clerezza/rdf/core/access => dataset/src/test/java/org/apache/clerezza/dataset}/providers/WeightedBlight.java (81%)
copy {rdf/core/src/test/java/org/apache/clerezza/rdf/core/access => dataset/src/test/java/org/apache/clerezza/dataset}/providers/WeightedDummy.java (87%)
[clerezza] 01/02: CLEREZZA-1026: Update version in sparql module
Posted by ha...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
hasan pushed a commit to branch reunited
in repository https://gitbox.apache.org/repos/asf/clerezza.git
commit ec0265f08e8e32923dc2633ea2e3b613b46ff316
Author: Hasan <ha...@apache.org>
AuthorDate: Sun Feb 3 18:29:03 2019 +0100
CLEREZZA-1026: Update version in sparql module
---
sparql/pom.xml | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/sparql/pom.xml b/sparql/pom.xml
index 10e64ad..4b93faa 100644
--- a/sparql/pom.xml
+++ b/sparql/pom.xml
@@ -31,7 +31,7 @@
<artifactId>sparql</artifactId>
<packaging>bundle</packaging>
- <version>1.0.2-SNAPSHOT</version>
+ <version>8-SNAPSHOT</version>
<name>Clerezza - SPARQL</name>
<description>Model SPARQL query and update</description>
[clerezza] 02/02: CLEREZZA-1031: Move rdf.core access to a new
module called dataset
Posted by ha...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
hasan pushed a commit to branch reunited
in repository https://gitbox.apache.org/repos/asf/clerezza.git
commit 50211e4260e2b30e4b36ea95be29f3bbbb1fc811
Author: Hasan <ha...@apache.org>
AuthorDate: Sun Feb 3 18:36:35 2019 +0100
CLEREZZA-1031: Move rdf.core access to a new module called dataset
---
dataset/pom.xml | 114 ++++
.../dataset/EntityAlreadyExistsException.java | 50 ++
.../dataset/EntityUndeletableException.java | 50 ++
.../dataset/ImmutableGraphServiceFactory.java | 58 ++
.../clerezza/dataset/MGraphServiceFactory.java | 54 ++
.../clerezza/dataset/NoSuchEntityException.java | 51 ++
.../clerezza/dataset/QueryableTcProvider.java | 41 ++
.../org/apache/clerezza/dataset/SecuredGraph.java | 191 +++++++
.../org/apache/clerezza/dataset/TcManager.java | 613 +++++++++++++++++++++
.../org/apache/clerezza/dataset/TcProvider.java | 151 +++++
.../clerezza/dataset/TcProviderMultiplexer.java | 446 +++++++++++++++
.../dataset/WeightedProviderComparator.java | 41 ++
.../clerezza/dataset/WeightedTcProvider.java | 36 ++
.../java/org/apache/clerezza/dataset/package.html | 56 ++
.../dataset/security/TcAccessController.java | 342 ++++++++++++
.../clerezza/dataset/security/TcPermission.java | 149 +++++
.../org/apache/clerezza/dataset/SecurityTest.java | 175 ++++++
.../org/apache/clerezza/dataset/TcManagerTest.java | 299 ++++++++++
.../clerezza/dataset/providers/WeightedA.java | 103 ++++
.../clerezza/dataset/providers/WeightedA1.java | 103 ++++
.../clerezza/dataset/providers/WeightedAHeavy.java | 101 ++++
.../clerezza/dataset/providers/WeightedBlight.java | 106 ++++
.../clerezza/dataset/providers/WeightedDummy.java | 155 ++++++
23 files changed, 3485 insertions(+)
diff --git a/dataset/pom.xml b/dataset/pom.xml
new file mode 100644
index 0000000..3ce095f
--- /dev/null
+++ b/dataset/pom.xml
@@ -0,0 +1,114 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!--
+
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements. See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+-->
+
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+ xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>org.apache.clerezza</groupId>
+ <artifactId>clerezza</artifactId>
+ <version>8-SNAPSHOT</version>
+ <relativePath/>
+ </parent>
+
+ <artifactId>dataset</artifactId>
+ <packaging>bundle</packaging>
+ <version>8-SNAPSHOT</version>
+ <name>Clerezza - DataSet</name>
+ <description>Interfaces and utilities to access RDF Graphs</description>
+
+ <dependencies>
+ <dependency>
+ <groupId>org.apache.clerezza</groupId>
+ <artifactId>api</artifactId>
+ <version>8-SNAPSHOT</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.clerezza</groupId>
+ <artifactId>api.impl</artifactId>
+ <version>8-SNAPSHOT</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.clerezza</groupId>
+ <artifactId>sparql</artifactId>
+ <version>8-SNAPSHOT</version>
+ </dependency>
+ <dependency>
+ <groupId>org.osgi</groupId>
+ <artifactId>org.osgi.core</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.osgi</groupId>
+ <artifactId>org.osgi.compendium</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>org.apache.felix.scr.annotations</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>org.apache.felix.scr.ds-annotations</artifactId>
+ <version>1.2.8</version>
+ </dependency>
+ <dependency>
+ <groupId>org.apache.clerezza</groupId>
+ <artifactId>utils</artifactId>
+ <version>0.2</version>
+ </dependency>
+ <dependency>
+ <groupId>junit</groupId>
+ <artifactId>junit</artifactId>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.mockito</groupId>
+ <artifactId>mockito-core</artifactId>
+ <version>1.9.5</version>
+ <scope>test</scope>
+ </dependency>
+ </dependencies>
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-bundle-plugin</artifactId>
+ <extensions>true</extensions>
+ <configuration>
+ <instructions>
+ <Export-Package>org.apache.clerezza.dataset.*</Export-Package>
+ </instructions>
+ </configuration>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.felix</groupId>
+ <artifactId>maven-scr-plugin</artifactId>
+ <executions>
+ <execution>
+ <id>generate-scr-scrdescriptor</id>
+ <goals>
+ <goal>scr</goal>
+ </goals>
+ </execution>
+ </executions>
+ </plugin>
+ </plugins>
+ </build>
+</project>
diff --git a/dataset/src/main/java/org/apache/clerezza/dataset/EntityAlreadyExistsException.java b/dataset/src/main/java/org/apache/clerezza/dataset/EntityAlreadyExistsException.java
new file mode 100644
index 0000000..15dcb56
--- /dev/null
+++ b/dataset/src/main/java/org/apache/clerezza/dataset/EntityAlreadyExistsException.java
@@ -0,0 +1,50 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.clerezza.dataset;
+
+import org.apache.clerezza.api.IRI;
+
+/**
+ * is thrown on an attempt to create an entity with a name which already exists
+ *
+ * @author hasan
+ */
+public class EntityAlreadyExistsException extends RuntimeException {
+
+ private IRI entityName;
+
+ /**
+ * creates an exception indicating that an entity with the specified name
+ * already exists.
+ *
+ * @param entityName the name of the entity which already exists
+ */
+ public EntityAlreadyExistsException(IRI entityName) {
+ super("An entity with this name already exists: "+entityName);
+ this.entityName = entityName;
+ }
+
+ /**
+ *
+ * @return the name of the entity which already exists
+ */
+ public IRI getEntityName() {
+ return entityName;
+ }
+}
diff --git a/dataset/src/main/java/org/apache/clerezza/dataset/EntityUndeletableException.java b/dataset/src/main/java/org/apache/clerezza/dataset/EntityUndeletableException.java
new file mode 100644
index 0000000..32c5088
--- /dev/null
+++ b/dataset/src/main/java/org/apache/clerezza/dataset/EntityUndeletableException.java
@@ -0,0 +1,50 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.clerezza.dataset;
+
+import org.apache.clerezza.api.IRI;
+
+/**
+ * is thrown on an attempt to delete an entity with a provider that
+ * supports the delete operation when the specified entity cannot be deleted
+ *
+ * @author reto
+ */
+public class EntityUndeletableException extends RuntimeException {
+ private IRI entityName;
+
+ /**
+ * creates an exception indicating that the entity with the specified name
+ * cannot be deleted
+ *
+ * @param entityName the name of the entity which is undeletable
+ */
+ public EntityUndeletableException(IRI entityName) {
+ super("This entity is undeletable: "+entityName);
+ this.entityName = entityName;
+ }
+
+ /**
+ *
+ * @return the name of the entity which is undeletable
+ */
+ public IRI getEntityName() {
+ return entityName;
+ }
+}
diff --git a/dataset/src/main/java/org/apache/clerezza/dataset/ImmutableGraphServiceFactory.java b/dataset/src/main/java/org/apache/clerezza/dataset/ImmutableGraphServiceFactory.java
new file mode 100644
index 0000000..b775d82
--- /dev/null
+++ b/dataset/src/main/java/org/apache/clerezza/dataset/ImmutableGraphServiceFactory.java
@@ -0,0 +1,58 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.clerezza.dataset;
+
+import org.apache.clerezza.api.Graph;
+import org.apache.clerezza.api.IRI;
+import org.apache.clerezza.dataset.security.TcAccessController;
+import org.osgi.framework.Bundle;
+import org.osgi.framework.ServiceFactory;
+import org.osgi.framework.ServiceRegistration;
+
+/**
+ * @see <a href="http://www.osgi.org/javadoc/r4v41/org/osgi/framework/ServiceFactory.html">
+ * Interface ServiceFactory</a>
+ *
+ * @author mir
+ */
+public class ImmutableGraphServiceFactory implements ServiceFactory {
+
+ private final TcManager tcManager;
+ private final IRI name;
+ private final TcAccessController tcAccessController;
+
+ ImmutableGraphServiceFactory(TcManager tcManager, IRI name,
+ TcAccessController tcAccessController) {
+ this.tcManager = tcManager;
+ this.name = name;
+ this.tcAccessController = tcAccessController;
+ }
+
+ @Override
+ public Object getService(Bundle arg0, ServiceRegistration arg1) {
+ Graph tc =
+ new SecuredGraph(tcManager.getImmutableGraph(name), name,
+ tcAccessController);
+ return tc.getImmutableGraph();
+ }
+
+ @Override
+ public void ungetService(Bundle arg0, ServiceRegistration arg1, Object arg2) {
+ }
+}
diff --git a/dataset/src/main/java/org/apache/clerezza/dataset/MGraphServiceFactory.java b/dataset/src/main/java/org/apache/clerezza/dataset/MGraphServiceFactory.java
new file mode 100644
index 0000000..cf3435c
--- /dev/null
+++ b/dataset/src/main/java/org/apache/clerezza/dataset/MGraphServiceFactory.java
@@ -0,0 +1,54 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.clerezza.dataset;
+
+import org.apache.clerezza.api.IRI;
+import org.apache.clerezza.dataset.security.TcAccessController;
+import org.osgi.framework.Bundle;
+import org.osgi.framework.ServiceFactory;
+import org.osgi.framework.ServiceRegistration;
+
+/**
+ * @see <a href="http://www.osgi.org/javadoc/r4v41/org/osgi/framework/ServiceFactory.html">
+ * Interface ServiceFactory</a>
+ *
+ * @author mir
+ */
+public class MGraphServiceFactory implements ServiceFactory {
+
+ private TcManager tcManager;
+ private IRI name;
+ private final TcAccessController tcAccessController;
+
+ MGraphServiceFactory(TcManager tcManager, IRI name,
+ TcAccessController tcAccessController) {
+ this.tcManager = tcManager;
+ this.name = name;
+ this.tcAccessController = tcAccessController;
+ }
+
+ @Override
+ public Object getService(Bundle arg0, ServiceRegistration arg1) {
+ return new SecuredGraph(tcManager.getMGraph(name), name, tcAccessController);
+ }
+
+ @Override
+ public void ungetService(Bundle arg0, ServiceRegistration arg1, Object arg2) {
+ }
+}
diff --git a/dataset/src/main/java/org/apache/clerezza/dataset/NoSuchEntityException.java b/dataset/src/main/java/org/apache/clerezza/dataset/NoSuchEntityException.java
new file mode 100644
index 0000000..789dc6b
--- /dev/null
+++ b/dataset/src/main/java/org/apache/clerezza/dataset/NoSuchEntityException.java
@@ -0,0 +1,51 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.clerezza.dataset;
+
+import org.apache.clerezza.api.IRI;
+
+/**
+ * is thrown on an attempt to perform an operation on an entity (i.e. a
+ * <code>ImmutableGraph</code> or <code>Graph</code> that does not exist.
+ *
+ * @author reto
+ */
+public class NoSuchEntityException extends RuntimeException {
+ private IRI entityName;
+
+ /**
+ * creates an exception indicating that the entity with the specified name
+ * does not exist.
+ *
+ * @param entityName the name for which no entity exists
+ */
+ public NoSuchEntityException(IRI entityName) {
+ super("No such entity: "+entityName);
+ this.entityName = entityName;
+ }
+
+ /**
+ * the name for which no entity exists.
+ *
+ * @return the name of the entity that doesn't exist
+ */
+ public IRI getEntityName() {
+ return entityName;
+ }
+}
diff --git a/dataset/src/main/java/org/apache/clerezza/dataset/QueryableTcProvider.java b/dataset/src/main/java/org/apache/clerezza/dataset/QueryableTcProvider.java
new file mode 100644
index 0000000..0490a4c
--- /dev/null
+++ b/dataset/src/main/java/org/apache/clerezza/dataset/QueryableTcProvider.java
@@ -0,0 +1,41 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.clerezza.dataset;
+
+import org.apache.clerezza.api.IRI;
+
+/**
+ * Extends the TcProvider interface for providers that support sparql queries.
+ */
+public interface QueryableTcProvider extends TcProvider {
+
+ /**
+ * Executes any sparql query. The type of the result object will vary
+ * depending on the type of the query.
+ *
+ * @param query
+ * the sparql query to execute
+ * @param defaultGraph
+ * the default ImmutableGraph against which to execute the query if not
+ * FROM clause is present
+ * @return the resulting ResultSet, ImmutableGraph or Boolean value
+ */
+ public Object executeSparqlQuery(String query, IRI defaultGraphUri);
+
+}
diff --git a/dataset/src/main/java/org/apache/clerezza/dataset/SecuredGraph.java b/dataset/src/main/java/org/apache/clerezza/dataset/SecuredGraph.java
new file mode 100644
index 0000000..afc2102
--- /dev/null
+++ b/dataset/src/main/java/org/apache/clerezza/dataset/SecuredGraph.java
@@ -0,0 +1,191 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.clerezza.dataset;
+
+import org.apache.clerezza.api.*;
+import org.apache.clerezza.api.impl.graph.SimpleImmutableGraph;
+import org.apache.clerezza.api.impl.graph.WriteBlockedGraph;
+import org.apache.clerezza.dataset.security.TcAccessController;
+
+import java.security.AccessControlException;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.concurrent.locks.ReadWriteLock;
+
+/**
+ * A Secured triple collection wraps a triple collection checking each access
+ * for the rights on a the ImmutableGraph for which the uri is passed to the
+ * constructor.
+ *
+ * @author mir, hasan
+ */
+public class SecuredGraph implements Graph {
+
+ private final Graph wrapped;
+ private final IRI name;
+ private final TcAccessController tcAccessController;
+
+ public SecuredGraph(Graph wrapped, IRI name,
+ TcAccessController tcAccessController) {
+ this.wrapped = wrapped;
+ this.name = name;
+ this.tcAccessController = tcAccessController;
+ }
+
+ @Override
+ public Iterator<Triple> filter(final BlankNodeOrIRI subject, final IRI predicate, final RDFTerm object) {
+ final Iterator<Triple> baseIter = wrapped.filter(subject, predicate, object);
+ return new Iterator<Triple>() {
+
+ @Override
+ public boolean hasNext() {
+ checkRead();
+ return baseIter.hasNext();
+ }
+
+ @Override
+ public Triple next() {
+ checkRead();
+ return baseIter.next();
+ }
+
+ @Override
+ public void remove() {
+ checkWrite();
+ baseIter.remove();
+ }
+ };
+ }
+
+ @Override
+ public int size() {
+ checkRead();
+ return wrapped.size();
+ }
+
+ @Override
+ public boolean isEmpty() {
+ checkRead();
+ return wrapped.isEmpty();
+ }
+
+ @Override
+ public Object[] toArray() {
+ checkRead();
+ return wrapped.toArray();
+ }
+
+ @Override
+ public <T> T[] toArray(T[] a) {
+ checkRead();
+ return wrapped.toArray(a);
+ }
+
+ @Override
+ public boolean add(Triple e) {
+ checkWrite();
+ return wrapped.add(e);
+ }
+
+ @Override
+ public boolean remove(Object o) {
+ checkWrite();
+ return wrapped.remove(o);
+ }
+
+ @Override
+ public boolean addAll(Collection<? extends Triple> c) {
+ checkWrite();
+ return wrapped.addAll(c);
+ }
+
+ @Override
+ public boolean removeAll(Collection<?> c) {
+ checkWrite();
+ return wrapped.removeAll(c);
+ }
+
+ @Override
+ public boolean retainAll(Collection<?> c) {
+ checkWrite();
+ return wrapped.retainAll(c);
+ }
+
+ @Override
+ public void clear() {
+ checkWrite();
+ wrapped.clear();
+ }
+
+ void checkRead() {
+ tcAccessController.checkReadPermission(name);
+ }
+
+ void checkWrite() {
+ tcAccessController.checkReadWritePermission(name);
+ }
+
+ @Override
+ public boolean contains(Object o) {
+ checkRead();
+ return wrapped.contains((Triple) o);
+ }
+
+
+ @Override
+ public Iterator<Triple> iterator() {
+ return filter(null, null, null);
+ }
+
+ @Override
+ public boolean containsAll(Collection<?> c) {
+ checkRead();
+ return wrapped.containsAll(c);
+ }
+
+ @Override
+ public ImmutableGraph getImmutableGraph() {
+ return new SimpleImmutableGraph(this);
+ }
+
+ @Override
+ public ReadWriteLock getLock() {
+ return wrapped.getLock();
+ }
+
+ /**
+ * Returns the wrapped Graph if the caller has all access rights.
+ * If the caller has only the read access right, then a write-blocked
+ * Graph is returned. If the caller has neither the read nor the write
+ * access right then an AccessControlException is thrown.
+ *
+ * @return the wrapped Graph or a write-block Graph depending
+ * on the access rights of the caller.
+ */
+ public Graph getUnsecuredGraph() {
+ try {
+ checkWrite();
+ return wrapped;
+ } catch (AccessControlException ex) {
+ checkRead();
+ return new WriteBlockedGraph(wrapped);
+ }
+
+ }
+}
diff --git a/dataset/src/main/java/org/apache/clerezza/dataset/TcManager.java b/dataset/src/main/java/org/apache/clerezza/dataset/TcManager.java
new file mode 100644
index 0000000..8981ad3
--- /dev/null
+++ b/dataset/src/main/java/org/apache/clerezza/dataset/TcManager.java
@@ -0,0 +1,613 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.clerezza.dataset;
+
+import org.apache.clerezza.api.Graph;
+import org.apache.clerezza.api.IRI;
+import org.apache.clerezza.api.ImmutableGraph;
+import org.apache.clerezza.api.impl.graph.SimpleGraph;
+import org.apache.clerezza.api.impl.graph.WriteBlockedGraph;
+import org.apache.clerezza.dataset.security.TcAccessController;
+import org.apache.clerezza.sparql.*;
+import org.apache.clerezza.sparql.query.*;
+import org.osgi.framework.Bundle;
+import org.osgi.framework.ServiceRegistration;
+import org.osgi.service.component.ComponentContext;
+import org.osgi.service.component.annotations.Component;
+import org.osgi.service.component.annotations.Reference;
+import org.osgi.service.component.annotations.ReferenceCardinality;
+import org.osgi.service.component.annotations.ReferencePolicy;
+
+import java.security.AccessControlException;
+import java.util.*;
+
+/**
+ * This class implements
+ * <code>TcManager</code>, delegating the actual provision and creation of
+ * Graphs or MGraphs to registered
+ * <code>TcProvider</code>s. The class attempts to satisfy the request using the
+ * register
+ * <code>WeightedTcProvider</code> in decreasing order of weight. If multiple
+ * providers have the same weight the lexicographical order of the fully
+ * qualified class name determines which one is used, namely the one that occurs
+ * earlier. If a call to a registered provider causes an
+ * <code>IllegalArgumentException</code>,
+ * <code>NoSuchEntityException</code> or
+ * <code>UnsupportedOperationException</code> then the call is delegated to the
+ * next provider.
+ *
+ * Only one instance of this class should exist in a system, the public no
+ * argument constructor is meant for initialization by dependency injection
+ * systems such as OSGi-DS. Applications should use the static
+ * <code>getInstance()</code> method if they aren't using a framework that
+ * injects them the instance.
+ *
+ * This class returns
+ * <code>Graph</code>s a subtype of
+ * <code>Graph</code> that allows read/write locks.
+ *
+ * This class also registers all Graphs as services with the property
+ * 'name' indicating there name.
+ *
+ * Security checks are done when a Graph is retrieved. The returned
+ * Graph will do no further security checks. Because of this it
+ * should not be passed to a context where different access control applies. If
+ * an Graph is retrieved without having write permission the returned graph
+ * will be read-only.
+ *
+ * If a Graphs needs to passed around across different security
+ * contexts the one retrieved from the OSGi service whiteboard should be used as
+ * this performs access control on every access.
+ *
+ * @author reto, mir, hasan
+ *
+ */
+//immedia is set to true as this should register the ImmutableGraph services (even if manager service is not required)
+@Component(service = TcManager.class, immediate = true,
+ property={
+ "graph.cache.enabled=true",
+ "Graph.services.enabled=true"})
+public class TcManager extends TcProviderMultiplexer implements GraphStore {
+
+ public final static String GENERAL_PURPOSE_TC = "general.purpose.tc";
+ public final static String Graph_SERVICES_ENABLED = "Graph.services.enabled";
+ public final static String MGRAPH_CACHE_ENABLED = "graph.cache.enabled";
+
+ private static volatile TcManager instance;
+ private TcAccessController tcAccessController = new TcAccessController() {
+
+ @Override
+ protected TcManager getTcManager() {
+ return TcManager.this;
+ }
+
+ };
+ private Map<IRI, ServiceRegistration> serviceRegistrations = Collections
+ .synchronizedMap(new HashMap<IRI, ServiceRegistration>());
+
+ protected QueryEngine queryEngine;
+ private boolean isActivated = false;
+ private boolean isTcServicesEnabled = true;
+
+ private ComponentContext componentContext;
+ protected SortedSet<WeightedTcProvider> tempProviderList = new TreeSet<WeightedTcProvider>(
+ new WeightedProviderComparator());
+
+ /**
+ * the constructor sets the singleton instance to allow instantiation by
+ * OSGi-DS. This constructor should not be called except by OSGi-DS,
+ * otherwise the static
+ * <code>getInstance</code> method should be used.
+ */
+ public TcManager() {
+ TcManager.instance = this;
+ }
+
+ /**
+ * This returns the singleton instance. If an instance has been previously
+ * created (e.g. by OSGi declarative services) this instance is returned,
+ * otherwise a new instance is created and providers are injected using the
+ * service provider interface (META-INF/services/)
+ *
+ * @return the singleton instance
+ */
+ public static TcManager getInstance() {
+ if (instance == null) {
+ synchronized (TcManager.class) {
+ if (instance == null) {
+ instance = new TcManager();
+ instance.isActivated = true;
+ Iterator<WeightedTcProvider> weightedProviders = ServiceLoader
+ .load(WeightedTcProvider.class).iterator();
+ while (weightedProviders.hasNext()) {
+ WeightedTcProvider weightedProvider = weightedProviders
+ .next();
+ instance
+ .bindWeightedTcProvider(weightedProvider);
+ }
+ Iterator<QueryEngine> queryEngines = ServiceLoader.load(
+ QueryEngine.class).iterator();
+ System.out.println("looking for QE");
+ if (queryEngines.hasNext()) {
+ instance.queryEngine = queryEngines.next();
+ System.out.println("QE: "
+ + instance.queryEngine.getClass());
+ }
+ }
+ }
+ }
+ return instance;
+ }
+
+ protected void activate(final ComponentContext componentContext) {
+ this.componentContext = componentContext;
+
+ // Read configuration
+ isTcServicesEnabled = true;
+ Object configTcServicesEnabled = componentContext.getProperties().get(Graph_SERVICES_ENABLED);
+ if ( configTcServicesEnabled != null && configTcServicesEnabled instanceof String ) {
+ isTcServicesEnabled = Boolean.valueOf((String)configTcServicesEnabled);
+ }
+ Object configCacheEnabled = componentContext.getProperties().get(MGRAPH_CACHE_ENABLED);
+ if ( configCacheEnabled != null && configCacheEnabled instanceof String ) {
+ setCachingEnabled(Boolean.valueOf((String)configCacheEnabled));
+ }
+ isActivated = true;
+
+ for (WeightedTcProvider provider : tempProviderList) {
+ addWeightedTcProvider(provider);
+ }
+ tempProviderList.clear();
+ }
+
+ protected void deactivate(final ComponentContext componentContext) {
+ for (ServiceRegistration registration : serviceRegistrations.values()) {
+ registration.unregister();
+ }
+ serviceRegistrations.clear();
+ this.componentContext = null;
+ isActivated = false;
+ }
+
+ @Override
+ public ImmutableGraph getImmutableGraph(IRI name) throws NoSuchEntityException {
+ tcAccessController.checkReadPermission(name);
+ return super.getImmutableGraph(name);
+ }
+
+ @Override
+ public Graph getMGraph(IRI name) {
+ try {
+ tcAccessController.checkReadWritePermission(name);
+ } catch (AccessControlException e) {
+ tcAccessController.checkReadPermission(name);
+ return new WriteBlockedGraph(super.getMGraph(name));
+ }
+ return super.getMGraph(name);
+ }
+
+ @Override
+ public Graph getGraph(IRI name) {
+ try {
+ tcAccessController.checkReadWritePermission(name);
+ } catch (AccessControlException e) {
+ tcAccessController.checkReadPermission(name);
+ return new WriteBlockedGraph(
+ super.getGraph(name));
+ }
+ return super.getGraph(name);
+ }
+
+ @Override
+ public Graph createGraph(IRI name)
+ throws UnsupportedOperationException {
+ tcAccessController.checkReadWritePermission(name);
+ return super.createGraph(name);
+ }
+
+ @Override
+ public ImmutableGraph createImmutableGraph(IRI name, Graph triples) {
+ tcAccessController.checkReadWritePermission(name);
+ return super.createImmutableGraph(name, triples);
+ }
+
+ @Override
+ public void deleteGraph(IRI name) {
+ tcAccessController.checkReadWritePermission(name);
+ super.deleteGraph(name);
+ }
+
+ @Override
+ public Set<IRI> getNames(ImmutableGraph ImmutableGraph) {
+ return super.getNames(ImmutableGraph);
+ }
+
+ @Override
+ public Set<IRI> listNamedGraphs() {
+ return this.listGraphs();
+ }
+
+ @Override
+ public Set<IRI> listGraphs() {
+ Set<IRI> result = super.listGraphs();
+ return excludeNonReadable(result);
+ }
+
+ @Override
+ public Set<IRI> listMGraphs() {
+ Set<IRI> result = super.listMGraphs();
+ return excludeNonReadable(result);
+ }
+
+ @Override
+ public Set<IRI> listImmutableGraphs() {
+ Set<IRI> result = super.listImmutableGraphs();
+ return excludeNonReadable(result);
+ }
+
+ private Set<IRI> excludeNonReadable(Set<IRI> tcNames) {
+ SecurityManager security = System.getSecurityManager();
+ if (security == null) {
+ return tcNames;
+ }
+ Set<IRI> result = new HashSet<IRI>();
+ for (IRI name : tcNames) {
+ try {
+ tcAccessController.checkReadPermission(name);
+ } catch (AccessControlException e) {
+ continue;
+ }
+ result.add(name);
+ }
+ return result;
+ }
+
+ /**
+ * Executes any sparql query. The type of the result object will vary
+ * depending on the type of the query. If the defaultGraph is available
+ * in this TcManages executeSparqlQuery(String, UriRef) should be used instead.
+ *
+ * @param query the sparql query to execute
+ * @param defaultGraph the default ImmutableGraph against which to execute the query
+ * if no FROM clause is present
+ * @return the resulting ResultSet, ImmutableGraph or Boolean value
+ */
+ public Object executeSparqlQuery(String query, Graph defaultGraph) throws ParseException {
+ TcProvider singleTargetTcProvider = null;
+
+ final IRI defaultGraphName = new IRI("urn:x-temp:/kjsfadfhfasdffds");
+ final SparqlPreParser sparqlPreParser = new SparqlPreParser(this);
+ final Set<IRI> referencedGraphs = sparqlPreParser.getReferredGraphs(query, defaultGraphName);
+ if ((referencedGraphs != null) && (!referencedGraphs.contains(defaultGraphName))) {
+ singleTargetTcProvider = getSingleTargetTcProvider(referencedGraphs);
+ }
+ if ((singleTargetTcProvider != null) && (singleTargetTcProvider instanceof QueryableTcProvider)) {
+ return ((QueryableTcProvider) singleTargetTcProvider).executeSparqlQuery(query, null);
+ }
+ final QueryEngine queryEngine = this.queryEngine;
+ if (queryEngine != null) {
+ return queryEngine.execute(this, defaultGraph, query);
+ } else {
+ throw new NoQueryEngineException();
+ }
+ }
+
+ /**
+ * Executes any sparql query. The type of the result object will vary
+ * depending on the type of the query. Note that this method only works for
+ * queries that do not need a default ImmutableGraph.
+ *
+ * @param query the sparql query to execute
+ * @param forceFastlane indicate whether to force fastlane usage.
+ * @return the resulting ResultSet, ImmutableGraph or Boolean value
+ */
+ public Object executeSparqlQuery(String query, boolean forceFastlane) throws ParseException {
+ TcProvider singleTargetTcProvider = null;
+ if (forceFastlane) {
+ singleTargetTcProvider = getSingleTargetTcProvider(Collections.EMPTY_SET);
+ } else {
+ final IRI defaultGraphName = new IRI("urn:x-temp:/kjsfadfhfasdffds");
+ SparqlPreParser sparqlPreParser = new SparqlPreParser(this);
+ final Set<IRI> referencedGraphs = sparqlPreParser.getReferredGraphs(query, defaultGraphName);
+ if ((referencedGraphs != null) && (!referencedGraphs.contains(defaultGraphName))) {
+ singleTargetTcProvider = getSingleTargetTcProvider(referencedGraphs);
+ }
+ }
+
+ if ((singleTargetTcProvider != null) && (singleTargetTcProvider instanceof QueryableTcProvider)) {
+ return ((QueryableTcProvider)singleTargetTcProvider).executeSparqlQuery(query, null);
+ }
+ final QueryEngine queryEngine = this.queryEngine;
+ if (queryEngine != null) {
+ return queryEngine.execute(this, new SimpleGraph(), query);
+ } else {
+ throw new NoQueryEngineException();
+ }
+ }
+
+ /**
+ * Executes any sparql query. The type of the result object will vary
+ * depending on the type of the query. If the defaultGraph is available
+ * in this TcManages executeSparqlQuery(String, UriRef) should be used instead.
+ *
+ * @param query the sparql query to execute
+ * @param defaultGraphName the ImmutableGraph to be used as default ImmutableGraph in the Sparql ImmutableGraph Store
+ * @return the resulting ResultSet, ImmutableGraph or Boolean value
+ */
+ public Object executeSparqlQuery(String query, IRI defaultGraphName) throws ParseException {
+ return executeSparqlQuery(query, defaultGraphName, false);
+ }
+
+ /**
+ * Executes any sparql query. The type of the result object will vary
+ * depending on the type of the query. If the defaultGraph is available
+ * in this TcManages executeSparqlQuery(String, UriRef) should be used instead.
+ *
+ * @param query the sparql query to execute
+ * @param defaultGraph the ImmutableGraph to be used as default ImmutableGraph in the Sparql ImmutableGraph Store
+ * @param forceFastlane indicate whether to force fastlane usage.
+ * @return the resulting ResultSet, ImmutableGraph or Boolean value
+ */
+ public Object executeSparqlQuery(String query, IRI defaultGraphName, boolean forceFastlane) throws ParseException {
+ TcProvider singleTargetTcProvider = null;
+ if (forceFastlane) {
+ singleTargetTcProvider = getSingleTargetTcProvider(Collections.singleton(defaultGraphName));
+ } else {
+ SparqlPreParser sparqlPreParser = new SparqlPreParser(this);
+ final Set<IRI> referencedGraphs = sparqlPreParser.getReferredGraphs(query, defaultGraphName);
+ if ((referencedGraphs != null)) {
+ singleTargetTcProvider = getSingleTargetTcProvider(referencedGraphs);
+ }
+ }
+ if ((singleTargetTcProvider != null) && (singleTargetTcProvider instanceof QueryableTcProvider)) {
+ return ((QueryableTcProvider)singleTargetTcProvider).executeSparqlQuery(query, defaultGraphName);
+ }
+ final QueryEngine queryEngine = this.queryEngine;
+ if (queryEngine != null) {
+ return queryEngine.execute(this, this.getGraph(defaultGraphName), query);
+ } else {
+ throw new NoQueryEngineException();
+ }
+ }
+
+ /**
+ * Executes any sparql query. The type of the result object will vary
+ * depending on the type of the query.
+ *
+ * @param query the sparql query to execute
+ * @param defaultGraph the default ImmutableGraph against which to execute the query
+ * if no FROM clause is present
+ * @return the resulting ResultSet, ImmutableGraph or Boolean value
+ *
+ * @deprecated Query is discontinued
+ */
+ @Deprecated
+ public Object executeSparqlQuery(Query query, Graph defaultGraph) {
+ final QueryEngine queryEngine = this.queryEngine;
+ if (queryEngine != null) {
+ return queryEngine.execute(this, defaultGraph, query.toString());
+ } else {
+ throw new NoQueryEngineException();
+ }
+ }
+
+ /**
+ * Executes a sparql SELECT query.
+ *
+ * @param query the sparql SELECT query to execute
+ * @param defaultGraph the default ImmutableGraph against which to execute the query
+ * if not FROM clause is present
+ * @return the resulting ResultSet
+ * @deprecated Query is discontinued
+ */
+ @Deprecated
+ public ResultSet executeSparqlQuery(SelectQuery query,
+ Graph defaultGraph) {
+ return (ResultSet) executeSparqlQuery((Query) query, defaultGraph);
+ }
+
+ /**
+ * Executes a sparql ASK query.
+ *
+ * @param query the sparql ASK query to execute
+ * @param defaultGraph the default ImmutableGraph against which to execute the query
+ * if not FROM clause is present
+ * @return the boolean value this query evaluates to
+ * @deprecated Query is discontinued
+ */
+ @Deprecated
+ public boolean executeSparqlQuery(AskQuery query,
+ Graph defaultGraph) {
+ return (Boolean) executeSparqlQuery((Query) query, defaultGraph);
+ }
+
+ /**
+ * Executes a sparql DESCRIBE query.
+ *
+ * @param query the sparql DESCRIBE query to execute
+ * @param defaultGraph the default ImmutableGraph against which to execute the query
+ * if not FROM clause is present
+ * @return the resulting ImmutableGraph
+ * @deprecated Query is discontinued
+ */
+ @Deprecated
+ public ImmutableGraph executeSparqlQuery(DescribeQuery query,
+ Graph defaultGraph) {
+ return (ImmutableGraph) executeSparqlQuery((Query) query, defaultGraph);
+ }
+
+ /**
+ * Executes a sparql CONSTRUCT query.
+ *
+ * @param query the sparql CONSTRUCT query to execute
+ * @param defaultGraph the default ImmutableGraph against which to execute the query
+ * if not FROM clause is present
+ * @return the resulting ImmutableGraph
+ * @deprecated Query is discontinued
+ */
+ @Deprecated
+ public ImmutableGraph executeSparqlQuery(ConstructQuery query,
+ Graph defaultGraph) {
+ return (ImmutableGraph) executeSparqlQuery((Query) query, defaultGraph);
+ }
+
+ /**
+ * @return the TcAccessController that can be used to set the permissions
+ * needed to access a Triple Collection
+ */
+ public TcAccessController getTcAccessController() {
+ return tcAccessController;
+ }
+
+ /**
+ * Registers a provider
+ *
+ * @param provider the provider to be registered
+ */
+ @Reference(policy = ReferencePolicy.DYNAMIC,
+ cardinality = ReferenceCardinality.MULTIPLE)
+ protected void bindWeightedTcProvider(WeightedTcProvider provider) {
+ if (isActivated) {
+ addWeightedTcProvider(provider);
+ } else {
+ tempProviderList.add(provider);
+ }
+ }
+
+ /**
+ * Unregister a provider
+ *
+ * @param provider the provider to be deregistered
+ */
+ protected void unbindWeightedTcProvider(
+ WeightedTcProvider provider) {
+ removeWeightedTcProvider(provider);
+ }
+
+ /**
+ * Registers a provider
+ *
+ * @param provider the provider to be registered
+ */
+ @Reference(policy = ReferencePolicy.DYNAMIC,
+ cardinality = ReferenceCardinality.AT_LEAST_ONE,
+ target = "("+ TcManager.GENERAL_PURPOSE_TC+"=true)")
+ protected void bindGpWeightedTcProvider(WeightedTcProvider provider) {
+ if (isActivated) {
+ addWeightedTcProvider(provider);
+ } else {
+ tempProviderList.add(provider);
+ }
+ }
+
+ /**
+ * Unregister a provider
+ *
+ * @param provider the provider to be deregistered
+ */
+ protected void unbindGpWeightedTcProvider(
+ WeightedTcProvider provider) {
+ removeWeightedTcProvider(provider);
+ }
+
+ @Reference(policy = ReferencePolicy.DYNAMIC,
+ cardinality = ReferenceCardinality.OPTIONAL)
+ protected void bindQueryEngine(QueryEngine queryEngine) {
+ this.queryEngine = queryEngine;
+ }
+
+ protected void unbindQueryEngine(QueryEngine queryEngine) {
+ this.queryEngine = null;
+ }
+
+ @Override
+ protected void mGraphAppears(IRI name) {
+ if (isTcServicesEnabled()) {
+ // Only create the service when activated. When not activated
+ // creating will be delayed till after activation.
+ if (componentContext != null) {
+ registerGraphAsService(name, true);
+ }
+ }
+ }
+
+ @Override
+ protected void graphAppears(IRI name) {
+ if (isTcServicesEnabled()) {
+ // Only create the service when activated. When not activated
+ // creating will be delayed till after activation.
+ if (componentContext != null) {
+ registerGraphAsService(name, false);
+ }
+ }
+ }
+
+ private void registerGraphAsService(IRI name, boolean isMGraph) {
+ Dictionary<String,Object> props = new Hashtable<String, Object>();
+ props.put("name", name.getUnicodeString());
+ String[] interfaceNames;
+ Object service;
+ if (isMGraph) {
+ interfaceNames = new String[]{
+ Graph.class.getName(),
+ Graph.class.getName()
+ };
+ service = new MGraphServiceFactory(this, name, tcAccessController);
+ } else {
+ interfaceNames = new String[]{ImmutableGraph.class.getName()};
+ service = new ImmutableGraphServiceFactory(this, name, tcAccessController);
+ }
+ final int bundleState = componentContext.getBundleContext().getBundle().getState();
+ if ((bundleState == Bundle.ACTIVE) || (bundleState == Bundle.STARTING)) {
+ ServiceRegistration serviceReg = componentContext.getBundleContext()
+ .registerService(interfaceNames, service, props);
+ serviceRegistrations.put(name, serviceReg);
+ }
+ }
+
+ @Override
+ protected void tcDisappears(IRI name) {
+ ServiceRegistration reg = serviceRegistrations.get(name);
+ if (reg != null) {
+ reg.unregister();
+ serviceRegistrations.remove(name);
+ }
+ }
+
+ private TcProvider getSingleTargetTcProvider(final Set<IRI> referencedGraphs) {
+ TcProvider singleTargetTcProvider = null;
+ for (WeightedTcProvider provider : providerList) {
+ final Set<IRI> providerGraphs = provider.listGraphs();
+ if (providerGraphs.containsAll(referencedGraphs)) {
+ singleTargetTcProvider = provider;
+ break; //success
+ }
+ for (IRI graphName : referencedGraphs) {
+ if (providerGraphs.contains(graphName)) {
+ break; //failure
+ }
+ }
+ }
+ return singleTargetTcProvider;
+ }
+
+ public boolean isTcServicesEnabled() {
+ return isTcServicesEnabled;
+ }
+}
diff --git a/dataset/src/main/java/org/apache/clerezza/dataset/TcProvider.java b/dataset/src/main/java/org/apache/clerezza/dataset/TcProvider.java
new file mode 100644
index 0000000..6135790
--- /dev/null
+++ b/dataset/src/main/java/org/apache/clerezza/dataset/TcProvider.java
@@ -0,0 +1,151 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.clerezza.dataset;
+
+import org.apache.clerezza.api.Graph;
+import org.apache.clerezza.api.IRI;
+import org.apache.clerezza.api.ImmutableGraph;
+
+import java.util.Set;
+
+/**
+ * A TC (Graph) Provider allows access to and optionally
+ * creation of named {@link ImmutableGraph}s and {@link Graph}s (mutable graphs)
+ *
+ * @author reto
+ */
+public interface TcProvider {
+
+ /**
+ * Get a <code>ImmutableGraph</code> by its name
+ *
+ * @param name the name of the ImmutableGraph
+ * @return the <code>ImmutableGraph</code> with the specified name
+ * @throws NoSuchEntityException if there is no <code>ImmutableGraph</code>
+ * with the specified name
+ */
+ ImmutableGraph getImmutableGraph(IRI name) throws NoSuchEntityException;
+
+ /**
+ * Get an <code>Graph</code> taht is not <code>ImmutableGrah</code>. The instances
+ * returned in different invocations are <code>equals</code>.
+ *
+ * @param the name of the <code>Graph</code>
+ * @return name the <code>Graph</code> with the specified name
+ * @throws NoSuchEntityException if there is no <code>Graph</code>
+ * with the specified name
+ */
+ Graph getMGraph(IRI name) throws NoSuchEntityException;
+
+ /**
+ * This method is used to get a <code>Graph</code> indifferently
+ * whether it's a ImmutableGraph or not. If the <code>name</code> names an
+ * <code>Graph</code> the result is the same as when invoking
+ * <code>getMGraph</code> with that argument, analogously for
+ * <code>ImmutableGraph</code>S the method returns an instance equals to what
+ * <code>getImmutableGraph</code> would return.
+ *
+ * @param name the name of the <Code>ImmutableGraph</code> or <code>Graph</code>
+ * @return the <Code>ImmutableGraph</code> or <code>Graph</code>
+ * @throws NoSuchEntityException if there is no <code>ImmutableGraph</code>
+ * or <code>Graph</code> with the specified name
+ */
+ Graph getGraph(IRI name) throws NoSuchEntityException;
+
+ /**
+ * Lists the name of the <Code>ImmutableGraph</code>s available through this
+ * <code>TcProvider</code>, implementations may take into account the
+ * security context and omit <Code>ImmutableGraph</code>s for which access is not
+ * allowed.
+ *
+ * @return the list of <Code>ImmutableGraph</code>s
+ */
+ Set<IRI> listImmutableGraphs();
+
+ /**
+ * Lists the name of the <Code>Graph</code>s available through this
+ * <code>TcProvider</code> that are not <Code>ImmutableGraph</code>, implementations may take into account the
+ * security context and omit <Code>Graph</code>s for which access is not
+ * allowed.
+ *
+ * @return the list of <Code>Graph</code>s
+ */
+ Set<IRI> listMGraphs();
+
+ /**
+ * Lists the name of the <Code>Graph</code>s available through this
+ * <code>TcProvider</code> indifferently whether they are mutables or
+ * immutables, implementations may take into account the security context and
+ * omit <Code>Graph</code>s for which access is not allowed.
+ *
+ * @return the list of <Code>Graph</code>s
+ */
+ Set<IRI> listGraphs();
+
+ /**
+ * Creates an initially empty <code>Graph</code> with a specified name
+ *
+ * @param name names the new <code>Graph</code>
+ * @return the newly created <code>Graph</code>
+ * @throws UnsupportedOperationException if this provider doesn't support
+ * creating <code>Graph</code>S
+ * @throws EntityAlreadyExistsException if an Graph with the specified name
+ * already exists
+ */
+ Graph createGraph(IRI name) throws UnsupportedOperationException,
+ EntityAlreadyExistsException;
+
+ /**
+ * Creates a <code>ImmutableGraph</code> with a specified name
+ *
+ * @param name the name of the <code>ImmutableGraph</code> to be created
+ * @param triples the triples of the new <code>ImmutableGraph</code>
+ * @return the newly created <code>ImmutableGraph</code>
+ * @throws UnsupportedOperationException if this provider doesn't support
+ * creating <code>ImmutableGraph</code>S
+ * @throws EntityAlreadyExistsException if a ImmutableGraph with the specified name
+ * already exists
+ */
+ ImmutableGraph createImmutableGraph(IRI name, Graph triples)
+ throws UnsupportedOperationException, EntityAlreadyExistsException;
+
+ /**
+ * Deletes the <code>ImmutableGraph</code> or <code>Graph</code> of a specified name.
+ * If <code>name</code> references a ImmutableGraph and the ImmutableGraph has other names, it
+ * will still be available with those other names.
+ *
+ * @param name the entity to be removed
+ * @throws UnsupportedOperationException if this provider doesn't support
+ * entities deletion.
+ * @throws NoSuchEntityException if <code>name</code> doesn't refer to a
+ * <code>ImmutableGraph</code> or an <code>Graph</code>.
+ * @throws EntityUndeletableException if the specified ImmutableGraph is undeletable
+ */
+ void deleteGraph(IRI name) throws UnsupportedOperationException,
+ NoSuchEntityException, EntityUndeletableException;
+
+ /**
+ * get a set of the names of a <code>ImmutableGraph</code>
+ *
+ * @param ImmutableGraph
+ * @return the set names of <code>ImmutableGraph</code>, the set is empty if
+ * <code>ImmutableGraph</code> is unknown
+ */
+ Set<IRI> getNames(ImmutableGraph immutableGraph);
+}
diff --git a/dataset/src/main/java/org/apache/clerezza/dataset/TcProviderMultiplexer.java b/dataset/src/main/java/org/apache/clerezza/dataset/TcProviderMultiplexer.java
new file mode 100644
index 0000000..ceaddc3
--- /dev/null
+++ b/dataset/src/main/java/org/apache/clerezza/dataset/TcProviderMultiplexer.java
@@ -0,0 +1,446 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.clerezza.dataset;
+
+import org.apache.clerezza.api.Graph;
+import org.apache.clerezza.api.IRI;
+import org.apache.clerezza.api.ImmutableGraph;
+
+import java.lang.ref.WeakReference;
+import java.util.*;
+
+/**
+ * This makes a set of WeightedTcProvider appear as one TcProvider. It delegates
+ * requests to the WeightedTcProvider with the highest Weight
+ *
+ * @author reto
+ */
+public class TcProviderMultiplexer implements TcProvider {
+
+ protected SortedSet<WeightedTcProvider> providerList = new TreeSet<>(
+ new WeightedProviderComparator());
+ /**
+ * Mapping to Graph's and ServiceRegistration using their URI's as key.
+ * Makes sure that per URI only one instance of the Graph is used,
+ * otherwise the locks in the <code>Graph</code>s would have no effect
+ * between different instances and concurrency issues could occur.
+ */
+ private Map<IRI, MGraphHolder> mGraphCache = Collections.synchronizedMap(new HashMap<IRI, MGraphHolder>());
+
+ /**
+ * Flag to indicate whether mgraphs should be cached for faster access. By
+ * default caching is enabled for backward compatibility.
+ */
+ private boolean isCachingEnabled = true;
+
+ /**
+ * Registers a provider
+ *
+ * @param provider
+ * the provider to be registered
+ */
+ public void addWeightedTcProvider(WeightedTcProvider provider) {
+ providerList.add(provider);
+ updateGraphCache(provider, true);
+ }
+
+ /**
+ * Unregister a provider
+ *
+ * @param provider
+ * the provider to be deregistered
+ */
+ public void removeWeightedTcProvider(
+ WeightedTcProvider provider) {
+ providerList.remove(provider);
+ updateGraphCache(provider, false);
+ }
+
+ /**
+ * subclasses overwrite this method to be notified when a new
+ * ImmutableGraph is available (either because it has been created or being
+ * provided by a newly added WeightedTcProvider). The default implementation
+ * does nothing.
+ *
+ * @param name
+ */
+ protected void graphAppears(IRI name) {
+ }
+
+ /**
+ * subclasses overwrite this method to be notified when a new
+ * Graph is available (either because it has been created or being
+ * provided by a newly added WeightedTcProvider). The default implementation
+ * does nothing.
+ *
+ * @param name
+ */
+ protected void mGraphAppears(IRI name) {
+ }
+
+ /**
+ * subclasses overwrite this method to be notified whenGraph is
+ * no longer available (either because it has been deleted or bacause its
+ * WeightedTcProvider was removed). The default implementation does nothing.
+ *
+ * for implementational reasons even for name of Graph not
+ * previously registered.
+ *
+ * @param name
+ */
+ protected void tcDisappears(IRI name) {
+ }
+
+ /**
+ * Updates the lockableMGraphCache AFTER a new <code>provider</code> was
+ * bound or unbound.
+ * This method also takes care of registering and unregistering
+ * provided triple collections as services based on the weight of
+ * all affected providers.
+ *
+ * @param provider
+ * the provider that was added or removed
+ * @param providerAdded
+ * <code>boolean</code> that should be set as <code>true</code>
+ * if <code>provider</code> was added to
+ * <code>org.apache.clerezza.rdf.core.TcManager.providerList</code>
+ * otherwise <code>false</code>
+ */
+ private void updateGraphCache(WeightedTcProvider provider,
+ boolean providerAdded) {
+ Set<IRI> uriSet = provider.listGraphs();
+ if (!(uriSet == null || uriSet.isEmpty())) {
+ if (providerAdded) {
+ weightedProviderAdded(provider, uriSet);
+ } else {
+ weightedProviderRemoved(provider, uriSet);
+ }
+ }
+ }
+
+ private void weightedProviderAdded(WeightedTcProvider newProvider,
+ Set<IRI> newProvidedUris) {
+ Set<WeightedTcProvider> lowerWeightedProviderList = getLowerWeightedProvider(newProvider);
+ if (isCachingEnabled()) {
+ for (IRI name : newProvidedUris) {
+ final MGraphHolder holder = mGraphCache.get(name);
+ if ((holder != null) && (holder.getWeightedTcProvider() != null)) {
+ if (lowerWeightedProviderList.contains(holder.getWeightedTcProvider())) {
+ tcDisappears(name);
+ mGraphCache.remove(name);
+ } else {
+ continue;
+ }
+ }
+ Graph triples = newProvider.getGraph(name);
+ if (triples instanceof Graph) {
+ mGraphCache.put(name, new MGraphHolder(newProvider, ensureLockable((Graph)triples)));
+ mGraphAppears(name);
+ } else {
+ graphAppears(name);
+ }
+ }
+ }
+ }
+
+
+
+ private Set<WeightedTcProvider> getLowerWeightedProvider(
+ WeightedTcProvider newProvider) {
+ boolean referenceProviderPassed = false;
+ Set<WeightedTcProvider> lowerWeightedProviderList = new HashSet<WeightedTcProvider>();
+ for (WeightedTcProvider weightedProvider : providerList) {
+ if (referenceProviderPassed) {
+ lowerWeightedProviderList.add(weightedProvider);
+ } else if (newProvider.equals(weightedProvider)) {
+ referenceProviderPassed = true;
+ }
+ }
+ return lowerWeightedProviderList;
+ }
+
+ private void weightedProviderRemoved(WeightedTcProvider oldProvider,
+ Set<IRI> oldProvidedUris) {
+ for (IRI name : oldProvidedUris) {
+ final MGraphHolder holder = mGraphCache.get(name);
+ if ((holder != null) && (holder.getWeightedTcProvider() != null)
+ && holder.getWeightedTcProvider().equals(oldProvider)) {
+ tcDisappears(name);
+ mGraphCache.remove(name);
+
+ if (isCachingEnabled()) {
+ // check if another WeightedTcProvider has the Graph.
+ // And if so register as service.
+ for (WeightedTcProvider provider : providerList) {
+ try {
+ Graph triples = provider.getGraph(name);
+ if (triples instanceof Graph) {
+ mGraphCache.put(name, new MGraphHolder(provider, ensureLockable((Graph)triples)));
+ mGraphAppears(name);
+ } else {
+ graphAppears(name);
+ }
+ break;
+ } catch (NoSuchEntityException e) {
+ // continue;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ @Override
+ public ImmutableGraph getImmutableGraph(IRI name) throws NoSuchEntityException {
+ for (TcProvider provider : providerList) {
+ try {
+ return provider.getImmutableGraph(name);
+ } catch (NoSuchEntityException e) {
+ //we do nothing and try our luck with the next provider
+ } catch (IllegalArgumentException e) {
+ //we do nothing and try our luck with the next provider
+ }
+ }
+ throw new NoSuchEntityException(name);
+ }
+
+ @Override
+ public Graph getMGraph(IRI name)
+ throws NoSuchEntityException {
+ Graph result = getMGraphFromCache(name);
+ if (result == null) {
+ synchronized (this) {
+ result = getMGraphFromCache(name);
+ if (result == null) {
+ result = getUnsecuredMGraphAndAddToCache(name);
+ }
+ }
+ }
+ return result;
+ }
+
+ private Graph getMGraphFromCache(IRI name) {
+ MGraphHolder holder = mGraphCache.get(name);
+ if (holder == null) {
+ return null;
+ }
+ return holder.getMGraph();
+ }
+
+ private Graph getUnsecuredMGraphAndAddToCache(IRI name)
+ throws NoSuchEntityException {
+ for (WeightedTcProvider provider : providerList) {
+ try {
+ Graph providedMGraph = provider.getMGraph(name);
+ Graph result = ensureLockable(providedMGraph);
+
+ if (isCachingEnabled()) {
+ mGraphCache.put(name, new MGraphHolder(
+ provider, result));
+ }
+ return result;
+ } catch (NoSuchEntityException e) {
+ //we do nothing and try our luck with the next provider
+ } catch (IllegalArgumentException e) {
+ //we do nothing and try our luck with the next provider
+ }
+ }
+ throw new NoSuchEntityException(name);
+ }
+
+ @Override
+ public Graph getGraph(IRI name)
+ throws NoSuchEntityException {
+ Graph result;
+ for (WeightedTcProvider provider : providerList) {
+ try {
+ result = provider.getGraph(name);
+ if (result instanceof ImmutableGraph) {
+ return result;
+ } else {
+ // This is to ensure the Graph gets added to the cache
+ return getMGraph(name);
+ }
+ } catch (NoSuchEntityException e) {
+ //we do nothing and try our luck with the next provider
+ } catch (IllegalArgumentException e) {
+ //we do nothing and try our luck with the next provider
+ }
+ }
+ throw new NoSuchEntityException(name);
+ }
+
+ @Override
+ public Graph createGraph(IRI name)
+ throws UnsupportedOperationException {
+
+ for (WeightedTcProvider provider : providerList) {
+ try {
+ Graph result = provider.createGraph(name);
+ // unregisters a possible ImmutableGraph or Graph service under this name
+ // provided by a WeightedTcProvider with a lower weight.
+ tcDisappears(name);
+ if (isCachingEnabled()) {
+ mGraphCache.put(name, new MGraphHolder(provider, null));
+ }
+ mGraphAppears(name);
+ return result;
+ } catch (UnsupportedOperationException e) {
+ //we do nothing and try our luck with the next provider
+ } catch (IllegalArgumentException e) {
+ //we do nothing and try our luck with the next provider
+ }
+ }
+ throw new UnsupportedOperationException(
+ "No provider could create Graph.");
+ }
+
+ @Override
+ public ImmutableGraph createImmutableGraph(IRI name, Graph triples) {
+ for (WeightedTcProvider provider : providerList) {
+ try {
+ ImmutableGraph result = provider.createImmutableGraph(name, triples);
+
+ // unregisters a possible ImmutableGraph or Graph service under this name
+ // provided by a WeightedTcProvider with a lower weight.
+ tcDisappears(name);
+ if (isCachingEnabled()) {
+ mGraphCache.put(name, new MGraphHolder(provider, null));
+ }
+ graphAppears(name);
+ return result;
+ } catch (UnsupportedOperationException e) {
+ //we do nothing and try our luck with the next provider
+ } catch (IllegalArgumentException e) {
+ //we do nothing and try our luck with the next provider
+ }
+ }
+ throw new UnsupportedOperationException(
+ "No provider could create ImmutableGraph.");
+ }
+
+ @Override
+ public void deleteGraph(IRI name) {
+ for (TcProvider provider : providerList) {
+ try {
+ provider.deleteGraph(name);
+ final MGraphHolder holder = mGraphCache.get(name);
+ if ((holder != null)
+ && (holder.getWeightedTcProvider() != null)
+ && holder.getWeightedTcProvider().equals(provider)) {
+ tcDisappears(name);
+ mGraphCache.remove(name);
+ }
+ return;
+ } catch (UnsupportedOperationException e) {
+ // we do nothing and try our luck with the next provider
+ } catch (NoSuchEntityException e) {
+ //we do nothing and try our luck with the next provider
+ } catch (IllegalArgumentException e) {
+ //we do nothing and try our luck with the next provider
+ }
+ }
+ // this throws a NoSuchEntityException if the ImmutableGraph doesn't exist
+ getGraph(name);
+ // the entity exists but cannot be deleted
+ throw new UnsupportedOperationException(
+ "No provider could delete the entity.");
+ }
+
+ @Override
+ public Set<IRI> getNames(ImmutableGraph ImmutableGraph) {
+ Set<IRI> result = new HashSet<IRI>();
+ for (TcProvider provider : providerList) {
+ result.addAll(provider.getNames(ImmutableGraph));
+ }
+ return result;
+ }
+
+ @Override
+ public Set<IRI> listGraphs() {
+ Set<IRI> result = new HashSet<IRI>();
+ for (TcProvider provider : providerList) {
+ result.addAll(provider.listGraphs());
+ }
+ return result;
+ }
+
+ @Override
+ public Set<IRI> listMGraphs() {
+ Set<IRI> result = new HashSet<IRI>();
+ for (TcProvider provider : providerList) {
+ result.addAll(provider.listMGraphs());
+ }
+ return result;
+ }
+
+ @Override
+ public Set<IRI> listImmutableGraphs() {
+ Set<IRI> result = new HashSet<IRI>();
+ for (TcProvider provider : providerList) {
+ result.addAll(provider.listImmutableGraphs());
+ }
+ return result;
+ }
+
+ private Graph ensureLockable(Graph providedMGraph) {
+ //Graphs are alway locable now
+ return providedMGraph;
+ }
+
+ /**
+ * Contains an unsecured Graph, a ServiceRegistration and
+ * the WeightedTcProvider that generated the ImmutableGraph
+ */
+ private static class MGraphHolder {
+
+ private WeightedTcProvider tcProvider;
+ private WeakReference<Graph> mGraphReference;
+
+ MGraphHolder(WeightedTcProvider tcProvider, Graph graph) {
+ this.tcProvider = tcProvider;
+ this.mGraphReference = new WeakReference<Graph>(graph);
+ }
+
+ Graph getMGraph() {
+ return this.mGraphReference.get();
+ }
+
+ WeightedTcProvider getWeightedTcProvider() {
+ return this.tcProvider;
+ }
+ }
+
+ //methods for debuging / monitoring
+ public SortedSet<WeightedTcProvider> getProviderList() {
+ return providerList;
+ }
+
+ public boolean isCachingEnabled() {
+ return isCachingEnabled;
+ }
+
+ public void setCachingEnabled(boolean isCachingEnabled) {
+ this.isCachingEnabled = isCachingEnabled;
+
+ if (!isCachingEnabled()) {
+ mGraphCache.clear();
+ }
+ }
+}
diff --git a/dataset/src/main/java/org/apache/clerezza/dataset/WeightedProviderComparator.java b/dataset/src/main/java/org/apache/clerezza/dataset/WeightedProviderComparator.java
new file mode 100644
index 0000000..66752f3
--- /dev/null
+++ b/dataset/src/main/java/org/apache/clerezza/dataset/WeightedProviderComparator.java
@@ -0,0 +1,41 @@
+package org.apache.clerezza.dataset;
+/*
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ *
+*/
+
+
+import java.util.Comparator;
+
+/**
+ * Compares the WeightedTcManagementProviders, descending for weight and
+ * ascending by name
+ */
+public class WeightedProviderComparator implements Comparator<WeightedTcProvider> {
+
+ @Override
+ public int compare(WeightedTcProvider o1, WeightedTcProvider o2) {
+ int o1Weight = o1.getWeight();
+ int o2Weight = o2.getWeight();
+ if (o1Weight != o2Weight) {
+ return o2Weight - o1Weight;
+ }
+ return o1.getClass().toString().compareTo(o2.getClass().toString());
+ }
+}
diff --git a/dataset/src/main/java/org/apache/clerezza/dataset/WeightedTcProvider.java b/dataset/src/main/java/org/apache/clerezza/dataset/WeightedTcProvider.java
new file mode 100644
index 0000000..e50514d
--- /dev/null
+++ b/dataset/src/main/java/org/apache/clerezza/dataset/WeightedTcProvider.java
@@ -0,0 +1,36 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.clerezza.dataset;
+
+/**
+ * This interface is implemented by providers to which {@link TcManagerImpl}
+ * delegates.
+ *
+ * @author reto
+ */
+public interface WeightedTcProvider extends TcProvider {
+
+ /**
+ * Get the weight of this provider. {@link TcManager} will prioritize
+ * <code>TcProvider</code>s with greater weight.
+ *
+ * @return a positive number indicating the weight of the provider
+ */
+ int getWeight();
+}
diff --git a/dataset/src/main/java/org/apache/clerezza/dataset/package.html b/dataset/src/main/java/org/apache/clerezza/dataset/package.html
new file mode 100644
index 0000000..8d136ed
--- /dev/null
+++ b/dataset/src/main/java/org/apache/clerezza/dataset/package.html
@@ -0,0 +1,56 @@
+
+ <!--
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+-->
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+ <head>
+ <title>org.apache.clerezza.dataset</title>
+ <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+ </head>
+ <body>
+ <p>This package provides access to named {@link
+ org.apache.clerezza.api.ImmutableGraph}S and {@link
+ org.apache.clerezza.api.Graph}S that may originate from various
+ implementations.</p>
+ <h3>Accessing</h3>
+ <p>
+ If running in a dependency injection system you should get an instance
+ of
+ <code>TcManager</code>
+ by the framework, otherwise use the static method
+ <code>TcManager.getInstance</code>
+ .
+ </p>
+ <h3>Adding a provider</h3>
+ <p>A provider implements {@link WeightedTcProvider}.</p>
+ <p>
+ To work outside a component injection framework it contains a file
+ <code>META-INF/services/org.apache.clerezza.dataset.WeightedTcProvider</code>
+ containing the name of the implementing class.
+ </p>
+ <p>
+ To work in a OSGi-DS context the provider register a component
+ exposing
+ <code>org.apache.clerezza.dataset.WeightedTcProvider</code>
+ as service interface.
+ </p>
+ </body>
+</html>
\ No newline at end of file
diff --git a/dataset/src/main/java/org/apache/clerezza/dataset/security/TcAccessController.java b/dataset/src/main/java/org/apache/clerezza/dataset/security/TcAccessController.java
new file mode 100644
index 0000000..93b54ff
--- /dev/null
+++ b/dataset/src/main/java/org/apache/clerezza/dataset/security/TcAccessController.java
@@ -0,0 +1,342 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.clerezza.dataset.security;
+
+import org.apache.clerezza.api.*;
+import org.apache.clerezza.api.impl.TripleImpl;
+import org.apache.clerezza.api.impl.literal.LiteralFactory;
+import org.apache.clerezza.dataset.NoSuchEntityException;
+import org.apache.clerezza.dataset.TcManager;
+import org.apache.clerezza.utils.security.PermissionParser;
+
+import java.security.AccessControlException;
+import java.security.AccessController;
+import java.security.AllPermission;
+import java.security.Permission;
+import java.util.*;
+import java.util.concurrent.locks.Lock;
+
+/**
+ * Controls the permissions needed to access a triple collection provided by
+ * <code>TcManager</code>.
+ *
+ * Clients with a ConfigureTcAcessPermission can set the permissions required to
+ * access a Graph. These permissions are stored persistently in an
+ * Graph named urn:x-localinstance:/graph-access.graph
+ *
+ * Clients should get an instance from TcManager.getTcAccessController()
+ *
+ * @author reto
+ */
+public abstract class TcAccessController {
+
+ private final TcManager tcManager;
+ private final IRI permissionGraphName = new IRI("urn:x-localinstance:/graph-access.graph");
+ //we can't rely on ontology plugin in rdf core
+ private String ontologyNamespace = "http://clerezza.apache.org/2010/07/10/graphpermssions#";
+ private final IRI readPermissionListProperty = new IRI(ontologyNamespace + "readPermissionList");
+ private final IRI readWritePermissionListProperty = new IRI(ontologyNamespace + "readWritePermissionList");
+ /**
+ * The first item in the subject RDF list.
+ */
+ public static final IRI first = new IRI("http://www.w3.org/1999/02/22-rdf-syntax-ns#first");
+ /**
+ * The rest of the subject RDF list after the first item.
+ */
+ public static final IRI rest = new IRI("http://www.w3.org/1999/02/22-rdf-syntax-ns#rest");
+ public static final IRI rdfNil = new IRI("http://www.w3.org/1999/02/22-rdf-syntax-ns#nil");
+ private final Map<IRI, Collection<Permission>> readPermissionCache =
+ Collections.synchronizedMap(new HashMap<IRI, Collection<Permission>>());
+ private final Map<IRI, Collection<Permission>> readWritePermissionCache =
+ Collections.synchronizedMap(new HashMap<IRI, Collection<Permission>>());
+
+ /**
+ *
+ * @param tcManager the tcManager used to locate urn:x-localinstance:/graph-access.graph
+ */
+ public TcAccessController() {
+ this.tcManager = getTcManager();
+ }
+
+ public void checkReadPermission(IRI GraphUri) {
+ if (GraphUri.equals(permissionGraphName)) {
+ //This is world readable, as this prevents as from doingf things as
+ //priviledged during verfification
+ return;
+ }
+ SecurityManager security = System.getSecurityManager();
+ if (security != null) {
+ //will AllPermissions the rest is obsolete
+ try {
+ AccessController.checkPermission(new AllPermission());
+ } catch (AccessControlException e) {
+ Collection<Permission> perms = getRequiredReadPermissions(GraphUri);
+ if (perms.size() > 0) {
+ for (Permission permission : perms) {
+ AccessController.checkPermission(permission);
+ }
+ } else {
+ AccessController.checkPermission(new TcPermission(
+ GraphUri.getUnicodeString(), TcPermission.READ));
+ }
+ }
+ }
+ }
+
+ public void checkReadWritePermission(IRI GraphUri) {
+ SecurityManager security = System.getSecurityManager();
+ if (security != null) {
+ //will AllPermissions the rest is obsolete
+ try {
+ AccessController.checkPermission(new AllPermission());
+ } catch (AccessControlException e) {
+ if (GraphUri.equals(permissionGraphName)) {
+ AccessController.checkPermission(new TcPermission(
+ GraphUri.getUnicodeString(), TcPermission.READWRITE));
+ } else {
+ Collection<Permission> perms = getRequiredReadWritePermissions(GraphUri);
+ if (perms.size() > 0) {
+ for (Permission permission : perms) {
+ AccessController.checkPermission(permission);
+ }
+ } else {
+ AccessController.checkPermission(new TcPermission(
+ GraphUri.getUnicodeString(), TcPermission.READWRITE));
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Set the set of permissions required for read access to a triple-collection, if
+ * the set is non-empty the default TCPermisson is no longer required.
+ *
+ * @param GraphUri
+ * @param permissionDescriptions
+ */
+ public void setRequiredReadPermissionStrings(IRI GraphUri,
+ Collection<String> permissionDescriptions) {
+ readPermissionCache.remove(GraphUri);
+ final Graph permissionMGraph = getOrCreatePermisionGraph();
+ Lock l = permissionMGraph.getLock().writeLock();
+ l.lock();
+ try {
+ removeExistingRequiredReadPermissions(GraphUri, permissionMGraph);
+ final BlankNodeOrIRI permissionList = createList(permissionDescriptions.iterator(), permissionMGraph);
+ permissionMGraph.add(new TripleImpl(GraphUri,
+ readPermissionListProperty, permissionList));
+ } finally {
+ l.unlock();
+ }
+ }
+
+ /**
+ * Set the set of permissions required for read access to a triple-collection, if
+ * the set is non-empty the default TCPermisson is no longer required.
+ *
+ * @param GraphUri
+ * @param permissionDescriptions
+ */
+ public void setRequiredReadPermissions(IRI GraphUri,
+ Collection<Permission> permissions) {
+ Collection<String> permissionStrings = new ArrayList<String>();
+ for (Permission permission : permissions) {
+ permissionStrings.add(permission.toString());
+ }
+ setRequiredReadPermissionStrings(GraphUri, permissionStrings);
+ }
+
+ /**
+ * Set the set of permissions required for read-write access to a
+ * triple-collection, if
+ * the set is non-empty the default TCPermisson is no longer required.
+ *
+ * @param GraphUri
+ * @param permissionDescriptions
+ */
+ public void setRequiredReadWritePermissionStrings(IRI GraphUri,
+ Collection<String> permissionDescriptions) {
+ readWritePermissionCache.remove(GraphUri);
+ final Graph permissionMGraph = getOrCreatePermisionGraph();
+ Lock l = permissionMGraph.getLock().writeLock();
+ l.lock();
+ try {
+ removeExistingRequiredReadPermissions(GraphUri, permissionMGraph);
+ final BlankNodeOrIRI permissionList = createList(permissionDescriptions.iterator(), permissionMGraph);
+ permissionMGraph.add(new TripleImpl(GraphUri,
+ readWritePermissionListProperty, permissionList));
+ } finally {
+ l.unlock();
+ }
+ }
+
+ /**
+ * Set the set of permissions required for read-write access to a
+ * triple-collection, if
+ * the set is non-empty the default TCPermisson is no longer required.
+ *
+ * @param GraphUri
+ * @param permissionDescriptions
+ */
+ public void setRequiredReadWritePermissions(IRI GraphUri,
+ Collection<Permission> permissions) {
+ Collection<String> permissionStrings = new ArrayList<String>();
+ for (Permission permission : permissions) {
+ permissionStrings.add(permission.toString());
+ }
+ setRequiredReadWritePermissionStrings(GraphUri, permissionStrings);
+ }
+
+ /**
+ * Get the set of permissions required for read access to the
+ * triple-collection, the set may be empty meaning that the default
+ * TCPermission is required.
+ *
+ * @param GraphUri
+ * @return the collection of permissions
+ */
+ public Collection<Permission> getRequiredReadPermissions(IRI GraphUri) {
+ Collection<Permission> result = readPermissionCache.get(GraphUri);
+ if (result == null) {
+ result = new ArrayList<Permission>();
+ Collection<String> permissionStrings = getRequiredReadPermissionStrings(GraphUri);
+ for (String string : permissionStrings) {
+ result.add(PermissionParser.getPermission(string, getClass().getClassLoader()));
+ }
+ readPermissionCache.put(GraphUri, result);
+ }
+ return result;
+ }
+
+ /**
+ * Get the set of permissions required for read-write access to the
+ * triple-collection, the set may be empty meaning that the default
+ * TCPermission is required.
+ *
+ * @param GraphUri
+ * @return the collection of permissions
+ */
+ public Collection<Permission> getRequiredReadWritePermissions(IRI GraphUri) {
+ Collection<Permission> result = readWritePermissionCache.get(GraphUri);
+ if (result == null) {
+ result = new ArrayList<Permission>();
+ Collection<String> permissionStrings = getRequiredReadWritePermissionStrings(GraphUri);
+ for (String string : permissionStrings) {
+ result.add(PermissionParser.getPermission(string, getClass().getClassLoader()));
+ }
+ readWritePermissionCache.put(GraphUri, result);
+ }
+ return result;
+ }
+
+ private BlankNodeOrIRI createList(Iterator<String> iterator, Graph permissionMGraph) {
+ if (!iterator.hasNext()) {
+ return rdfNil;
+ }
+ final BlankNode result = new BlankNode();
+ permissionMGraph.add(new TripleImpl(result, first,
+ LiteralFactory.getInstance().createTypedLiteral(iterator.next())));
+ permissionMGraph.add(new TripleImpl(result, rest,
+ createList(iterator, permissionMGraph)));
+ return result;
+
+ }
+
+ //called withiong write-lock
+ private void removeExistingRequiredReadPermissions(IRI GraphUri,
+ Graph permissionMGraph) {
+ try {
+ Triple t = permissionMGraph.filter(GraphUri, readPermissionListProperty, null).next();
+ RDFTerm list = t.getObject();
+ removeList((BlankNodeOrIRI) list, permissionMGraph);
+ permissionMGraph.remove(t);
+ } catch (NoSuchElementException e) {
+ //There was no existing to remove
+ }
+ }
+
+ private void removeList(BlankNodeOrIRI list, Graph permissionMGraph) {
+ try {
+ Triple t = permissionMGraph.filter(list, rest, null).next();
+ RDFTerm restList = t.getObject();
+ removeList((BlankNodeOrIRI) restList, permissionMGraph);
+ permissionMGraph.remove(t);
+ Iterator<Triple> iter = permissionMGraph.filter(list, first, null);
+ iter.next();
+ iter.remove();
+ } catch (NoSuchElementException e) {
+ //if it has no rest its rdf:NIL and has no first
+ }
+ }
+
+ private Collection<String> getRequiredReadWritePermissionStrings(final IRI GraphUri) {
+ return getRequiredPermissionStrings(GraphUri, readWritePermissionListProperty);
+ }
+ private Collection<String> getRequiredReadPermissionStrings(final IRI GraphUri) {
+ return getRequiredPermissionStrings(GraphUri, readPermissionListProperty);
+ }
+ private Collection<String> getRequiredPermissionStrings(final IRI GraphUri, IRI property) {
+ try {
+ final Graph permissionMGraph = tcManager.getMGraph(permissionGraphName);
+ Lock l = permissionMGraph.getLock().readLock();
+ l.lock();
+ try {
+ Triple t = permissionMGraph.filter(GraphUri, property, null).next();
+ BlankNodeOrIRI list = (BlankNodeOrIRI) t.getObject();
+ LinkedList<String> result = new LinkedList<String>();
+ readList(list, permissionMGraph, result);
+ return result;
+ } catch (NoSuchElementException e) {
+ return new ArrayList<String>(0);
+ } finally {
+ l.unlock();
+ }
+ } catch (NoSuchEntityException e) {
+ return new ArrayList<String>(0);
+ }
+ }
+
+ private void readList(BlankNodeOrIRI list, Graph permissionMGraph, LinkedList<String> target) {
+ if (list.equals(rdfNil)) {
+ return;
+ }
+ Triple restTriple = permissionMGraph.filter(list, rest, null).next();
+ BlankNodeOrIRI restList = (BlankNodeOrIRI) restTriple.getObject();
+ readList(restList, permissionMGraph, target);
+ Triple firstTriple = permissionMGraph.filter(list, first, null).next();
+ Literal firstValue = (Literal) firstTriple.getObject();
+ String value = LiteralFactory.getInstance().createObject(String.class, firstValue);
+ target.addFirst(value);
+ }
+
+ private Graph getOrCreatePermisionGraph() {
+ try {
+ return tcManager.getMGraph(permissionGraphName);
+ } catch (NoSuchEntityException e) {
+ return tcManager.createGraph(permissionGraphName);
+ }
+ }
+
+ /**
+ * Note that this will only be invoked once
+ * @return
+ */
+ protected abstract TcManager getTcManager();
+}
diff --git a/dataset/src/main/java/org/apache/clerezza/dataset/security/TcPermission.java b/dataset/src/main/java/org/apache/clerezza/dataset/security/TcPermission.java
new file mode 100644
index 0000000..c218dd9
--- /dev/null
+++ b/dataset/src/main/java/org/apache/clerezza/dataset/security/TcPermission.java
@@ -0,0 +1,149 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.clerezza.dataset.security;
+
+import java.security.Permission;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.regex.Pattern;
+
+/**
+ * A permission to access <code>Graph<code>s matching a specified
+ * name pattern. A pattern is matched if and only if the pattern is equals
+ * to name of the <code>Graph<code> or the pattern ends with "/*" and
+ * the name of the <code>Graph<code> starts with the characters
+ * preceding the '*' in the pattern.
+ *
+ * @author reto, tsuy
+ */
+public class TcPermission extends Permission {
+ public final static String READWRITE = "readwrite";
+ public final static String READ = "read";
+
+ private String tcNamePattern;
+ /**
+ * true if readwrite granted false if only read
+ */
+ private boolean allowReadWrite = false;
+
+ final static Pattern actionPattern = Pattern.compile(",( *)");
+ /**
+ * Conststructs a TcPermission for a specified name pattern and a list of
+ * actions.
+ *
+ * @param tcNamePattern see class description
+ * @param actions a comma separated list of the strings "read" and "readwrite",
+ * the canonical form is just "read" or "readwrite" as "readwrite"
+ * implies "read".
+ */
+ public TcPermission(String tcNamePattern, String actions) {
+ super(tcNamePattern);
+ this.tcNamePattern = tcNamePattern;
+ //check and set actions
+ final Set actionSet = new HashSet(Arrays.asList(actionPattern.split(actions)));
+ if (actionSet.remove(READWRITE)) {
+ allowReadWrite = true;
+ } else {
+ if (!actionSet.contains(READ)) {
+ throw new IllegalArgumentException("actions must be either \"read\" or \"readwrite\"");
+ }
+ }
+ actionSet.remove(READ);
+ if (actionSet.size() > 0) {
+ throw new IllegalArgumentException("actions must only contain \"read\" and \"readwrite\"");
+ }
+ }
+
+ @Override
+ public boolean implies(Permission permission) {
+ if (permission instanceof TcPermission) {
+ TcPermission other = (TcPermission) permission;
+ if (!patternImplies(other.tcNamePattern)) {
+ return false;
+ }
+ if (!actionsImplies(other.allowReadWrite)) {
+ return false;
+ }
+ return true;
+
+
+ }
+ return false;
+ }
+
+ private boolean actionsImplies(boolean readwriteOther) {
+ if (!readwriteOther) {
+ return true;
+ } else {
+ return allowReadWrite;
+ }
+
+ }
+
+ private boolean patternImplies(String tcNamePatternOther) {
+ if (tcNamePattern.equals(tcNamePatternOther)) {
+ return true;
+ }
+ if (tcNamePattern.endsWith("/*")) {
+ return tcNamePatternOther.startsWith(
+ tcNamePattern.substring(0, tcNamePattern.length()-1));
+ }
+ return false;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == null) {
+ return false;
+ }
+ if (getClass() != obj.getClass()) {
+ return false;
+ }
+ final TcPermission other = (TcPermission) obj;
+ if (this.tcNamePattern != other.tcNamePattern
+ && (this.tcNamePattern == null
+ || !this.tcNamePattern.equals(other.tcNamePattern))) {
+ return false;
+ }
+ if (this.allowReadWrite != other.allowReadWrite) {
+ return false;
+ }
+ return true;
+ }
+
+ @Override
+ public int hashCode() {
+ int hash = 3;
+ hash = 97 * hash + (this.tcNamePattern != null ?
+ this.tcNamePattern.hashCode() : 0);
+ if (allowReadWrite) {
+ hash++;
+ }
+ return hash;
+ }
+
+
+
+ @Override
+ public String getActions() {
+ return allowReadWrite ? READWRITE : READ;
+ }
+
+}
diff --git a/dataset/src/test/java/org/apache/clerezza/dataset/SecurityTest.java b/dataset/src/test/java/org/apache/clerezza/dataset/SecurityTest.java
new file mode 100644
index 0000000..ffea930
--- /dev/null
+++ b/dataset/src/test/java/org/apache/clerezza/dataset/SecurityTest.java
@@ -0,0 +1,175 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.clerezza.dataset;
+
+import org.apache.clerezza.api.Graph;
+import org.apache.clerezza.api.IRI;
+import org.apache.clerezza.api.Triple;
+import org.apache.clerezza.api.impl.graph.ReadOnlyException;
+import org.apache.clerezza.api.impl.literal.PlainLiteralImpl;
+import org.apache.clerezza.api.impl.TripleImpl;
+import org.apache.clerezza.dataset.providers.WeightedA;
+import org.apache.clerezza.dataset.providers.WeightedDummy;
+import org.apache.clerezza.dataset.security.TcPermission;
+import org.junit.*;
+
+import java.io.FilePermission;
+import java.lang.reflect.ReflectPermission;
+import java.security.*;
+import java.util.Collections;
+import java.util.PropertyPermission;
+
+/**
+ *
+ * @author reto
+ */
+public class SecurityTest {
+
+ public SecurityTest() {
+ }
+
+ @BeforeClass
+ public static void setUpClass() throws Exception {
+ ////needed to unbind because this is injected with META-INF/services - file
+ TcManager.getInstance().unbindWeightedTcProvider(new WeightedA());
+ TcManager.getInstance().bindWeightedTcProvider(new WeightedDummy());
+ TcManager.getInstance().createGraph(new IRI("http://example.org/ImmutableGraph/alreadyexists"));
+ TcManager.getInstance().createGraph(new IRI("http://example.org/read/ImmutableGraph"));
+ }
+
+ @AfterClass
+ public static void tearDownClass() throws Exception {
+ }
+
+ @Before
+ public void setUp() {
+
+ Policy.setPolicy(new Policy() {
+
+ @Override
+ public PermissionCollection getPermissions(CodeSource codeSource) {
+ PermissionCollection result = new Permissions();
+ result.add(new TcPermission("http://example.org/permitted", "read"));
+ result.add(new TcPermission("http://example.org/ImmutableGraph/alreadyexists", "readwrite"));
+ result.add(new TcPermission("http://example.org/read/ImmutableGraph", "read"));
+ result.add(new TcPermission("http://example.org/area/allowed/*", "readwrite"));
+ result.add(new TcPermission("urn:x-localinstance:/graph-access.graph", "readwrite"));
+ //result.add(new AllPermission());
+ result.add(new RuntimePermission("*"));
+ result.add(new ReflectPermission("suppressAccessChecks"));
+ result.add(new PropertyPermission("*", "read"));
+ //(java.util.PropertyPermission line.separator read)
+ result.add(new FilePermission("/-", "read,write"));
+ return result;
+ }
+ });
+ System.setSecurityManager(new SecurityManager() {
+
+ @Override
+ public void checkPermission(Permission perm) {
+ //System.out.println("Checking "+perm);
+ super.checkPermission(perm);
+ }
+
+ @Override
+ public void checkPermission(Permission perm, Object context) {
+ //System.out.println("Checking "+perm);
+ super.checkPermission(perm, context);
+ }
+
+ });
+ }
+
+ @After
+ public void tearDown() {
+ System.setSecurityManager(null);
+ }
+
+
+ @Test(expected=NoSuchEntityException.class)
+ public void testAcessGraph() {
+ TcManager.getInstance().getImmutableGraph(new IRI("http://example.org/permitted"));
+ }
+
+ @Test(expected=AccessControlException.class)
+ public void testNoWildCard() {
+ TcManager.getInstance().getImmutableGraph(new IRI("http://example.org/permitted/subthing"));
+ }
+
+ @Test(expected=NoSuchEntityException.class)
+ public void testAllowedArea() {
+ TcManager.getInstance().getImmutableGraph(new IRI("http://example.org/area/allowed/something"));
+ }
+
+ @Test(expected=AccessControlException.class)
+ public void testAcessForbiddenGraph() {
+ TcManager.getInstance().getImmutableGraph(new IRI("http://example.org/forbidden"));
+ }
+
+ @Test(expected=NoSuchEntityException.class)
+ public void testCustomPermissions() {
+ IRI graphUri = new IRI("http://example.org/custom");
+ TcManager.getInstance().getTcAccessController().setRequiredReadPermissionStrings(graphUri,
+ Collections.singletonList("(java.io.FilePermission \"/etc\" \"write\")"));
+ //new FilePermission("/etc", "write").toString()));
+ Graph ag = TcManager.getInstance().getGraph(new IRI("urn:x-localinstance:/graph-access.graph"));
+ System.out.print(ag.toString());
+ TcManager.getInstance().getMGraph(graphUri);
+ }
+
+ @Test(expected=AccessControlException.class)
+ public void testCustomPermissionsIncorrect() {
+ IRI graphUri = new IRI("http://example.org/custom");
+ TcManager.getInstance().getTcAccessController().setRequiredReadPermissionStrings(graphUri,
+ Collections.singletonList("(java.io.FilePermission \"/etc\" \"write\")"));
+ //new FilePermission("/etc", "write").toString()));
+ Graph ag = TcManager.getInstance().getGraph(new IRI("urn:x-localinstance:/graph-access.graph"));
+ System.out.print(ag.toString());
+ TcManager.getInstance().createGraph(graphUri);
+ }
+
+ @Test
+ public void testCustomReadWritePermissions() {
+ IRI graphUri = new IRI("http://example.org/read-write-custom");
+ TcManager.getInstance().getTcAccessController().setRequiredReadWritePermissionStrings(graphUri,
+ Collections.singletonList("(java.io.FilePermission \"/etc\" \"write\")"));
+ //new FilePermission("/etc", "write").toString()));
+ Graph ag = TcManager.getInstance().getGraph(new IRI("urn:x-localinstance:/graph-access.graph"));
+ System.out.print(ag.toString());
+ TcManager.getInstance().createGraph(graphUri);
+ }
+
+ @Test(expected=EntityAlreadyExistsException.class)
+ public void testCreateMGraph() {
+ TcManager.getInstance().createGraph(new IRI("http://example.org/ImmutableGraph/alreadyexists"));
+ }
+ @Test(expected=AccessControlException.class)
+ public void testCreateMGraphWithoutWritePermission() {
+ TcManager.getInstance().createGraph(new IRI("http://example.org/read/ImmutableGraph"));
+ }
+ @Test(expected=ReadOnlyException.class)
+ public void testAddTripleToMGraph() {
+ Graph graph = TcManager.getInstance().getMGraph(new IRI("http://example.org/read/ImmutableGraph"));
+ Triple triple = new TripleImpl(
+ new IRI("http://example.org/definition/isNonLiteral"),
+ new IRI("http://example.org/definition/isTest"),
+ new PlainLiteralImpl("test"));
+ graph.add(triple);
+ }
+}
\ No newline at end of file
diff --git a/dataset/src/test/java/org/apache/clerezza/dataset/TcManagerTest.java b/dataset/src/test/java/org/apache/clerezza/dataset/TcManagerTest.java
new file mode 100644
index 0000000..619e86a
--- /dev/null
+++ b/dataset/src/test/java/org/apache/clerezza/dataset/TcManagerTest.java
@@ -0,0 +1,299 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.clerezza.dataset;
+
+import org.apache.clerezza.api.Graph;
+import org.apache.clerezza.api.IRI;
+import org.apache.clerezza.api.ImmutableGraph;
+import org.apache.clerezza.api.Triple;
+import org.apache.clerezza.api.impl.TripleImpl;
+import org.apache.clerezza.api.impl.graph.SimpleMGraph;
+import org.apache.clerezza.dataset.providers.WeightedA;
+import org.apache.clerezza.dataset.providers.WeightedA1;
+import org.apache.clerezza.dataset.providers.WeightedAHeavy;
+import org.apache.clerezza.dataset.providers.WeightedBlight;
+import org.apache.clerezza.sparql.NoQueryEngineException;
+import org.apache.clerezza.sparql.QueryEngine;
+import org.apache.clerezza.sparql.query.*;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+
+import java.lang.reflect.Field;
+import java.util.Iterator;
+
+import static org.junit.Assert.*;
+
+/**
+ *
+ * @author reto
+ */
+public class TcManagerTest {
+
+ public static IRI uriRefAHeavy = new IRI("http://example.org/aHeavy");
+ public static IRI uriRefB = new IRI("http://example.org/b");;
+ public static final IRI uriRefA = new IRI("http://example.org/a");
+ public static final IRI uriRefA1 = new IRI("http://example.org/a1");
+ private TcManager graphAccess;
+ private QueryEngine queryEngine;
+ private final WeightedA weightedA = new WeightedA();
+ private final WeightedA1 weightedA1 = new WeightedA1();
+ private WeightedTcProvider weightedBlight = new WeightedBlight();
+
+ @Before
+ public void setUp() {
+ graphAccess = TcManager.getInstance();
+ graphAccess.bindWeightedTcProvider(weightedA);
+ graphAccess.bindWeightedTcProvider(weightedA1);
+ graphAccess.bindWeightedTcProvider(weightedBlight);
+
+ queryEngine = Mockito.mock(QueryEngine.class);
+ }
+
+ @After
+ public void tearDown() {
+ graphAccess = TcManager.getInstance();
+ graphAccess.unbindWeightedTcProvider(weightedA);
+ graphAccess.unbindWeightedTcProvider(weightedA1);
+ graphAccess.unbindWeightedTcProvider(weightedBlight);
+
+ queryEngine = null;
+ }
+
+ @Test
+ public void getGraphFromA() {
+ ImmutableGraph graphA = graphAccess.getImmutableGraph(uriRefA);
+ Iterator<Triple> iterator = graphA.iterator();
+ assertEquals(new TripleImpl(uriRefA, uriRefA, uriRefA), iterator.next());
+ assertFalse(iterator.hasNext());
+ Graph triplesA = graphAccess.getGraph(uriRefA);
+ iterator = triplesA.iterator();
+ assertEquals(new TripleImpl(uriRefA, uriRefA, uriRefA), iterator.next());
+ assertFalse(iterator.hasNext());
+ }
+
+ @Test
+ public void getGraphFromB() {
+ ImmutableGraph graphA = graphAccess.getImmutableGraph(uriRefB);
+ Iterator<Triple> iterator = graphA.iterator();
+ assertEquals(new TripleImpl(uriRefB, uriRefB, uriRefB), iterator.next());
+ assertFalse(iterator.hasNext());
+ Graph triplesA = graphAccess.getGraph(uriRefB);
+ iterator = triplesA.iterator();
+ assertEquals(new TripleImpl(uriRefB, uriRefB, uriRefB), iterator.next());
+ assertFalse(iterator.hasNext());
+ }
+
+ @Test
+ public void getGraphFromAAfterUnbinding() {
+ graphAccess.unbindWeightedTcProvider(weightedA);
+ ImmutableGraph graphA = graphAccess.getImmutableGraph(uriRefA);
+ Iterator<Triple> iterator = graphA.iterator();
+ assertEquals(new TripleImpl(uriRefA1, uriRefA1, uriRefA1),
+ iterator.next());
+ assertFalse(iterator.hasNext());
+ Graph triplesA = graphAccess.getGraph(uriRefA);
+ iterator = triplesA.iterator();
+ assertEquals(new TripleImpl(uriRefA1, uriRefA1, uriRefA1),
+ iterator.next());
+ assertFalse(iterator.hasNext());
+ }
+
+ @Test
+ public void getGraphFromAWithHeavy() {
+ final WeightedAHeavy weightedAHeavy = new WeightedAHeavy();
+ graphAccess.bindWeightedTcProvider(weightedAHeavy);
+ ImmutableGraph graphA = graphAccess.getImmutableGraph(uriRefA);
+ Iterator<Triple> iterator = graphA.iterator();
+ assertEquals(new TripleImpl(uriRefAHeavy, uriRefAHeavy, uriRefAHeavy),
+ iterator.next());
+ assertFalse(iterator.hasNext());
+ Graph triplesA = graphAccess.getGraph(uriRefA);
+ iterator = triplesA.iterator();
+ assertEquals(new TripleImpl(uriRefAHeavy, uriRefAHeavy, uriRefAHeavy),
+ iterator.next());
+ assertFalse(iterator.hasNext());
+ graphAccess.unbindWeightedTcProvider(weightedAHeavy);
+ }
+
+ @Test(expected = NoQueryEngineException.class)
+ public void executeSparqlQueryNoEngineWithString() throws Exception {
+ // Prepare
+ injectQueryEngine(null);
+
+ // Execute
+ graphAccess.executeSparqlQuery("", new SimpleMGraph());
+ }
+
+ @Test(expected = NoQueryEngineException.class)
+ public void executeSparqlQueryNoEngineWithQuery() throws Exception {
+ // Prepare
+ injectQueryEngine(null);
+
+ // Execute
+ graphAccess.executeSparqlQuery((Query) null, new SimpleMGraph());
+ }
+
+ @Test(expected = NoQueryEngineException.class)
+ public void executeSparqlQueryNoEngineWithSelectQuery() throws Exception {
+ // Prepare
+ injectQueryEngine(null);
+
+ // Execute
+ graphAccess.executeSparqlQuery((SelectQuery) null, new SimpleMGraph());
+ }
+
+ @Test(expected = NoQueryEngineException.class)
+ public void executeSparqlQueryNoEngineWithAskQuery() throws Exception {
+ // Prepare
+ injectQueryEngine(null);
+
+ // Execute
+ graphAccess.executeSparqlQuery((AskQuery) null, new SimpleMGraph());
+ }
+
+ @Test(expected = NoQueryEngineException.class)
+ public void executeSparqlQueryNoEngineWithDescribeQuery() throws Exception {
+ // Prepare
+ injectQueryEngine(null);
+
+ // Execute
+ graphAccess
+ .executeSparqlQuery((DescribeQuery) null, new SimpleMGraph());
+ }
+
+ @Test(expected = NoQueryEngineException.class)
+ public void executeSparqlQueryNoEngineWithConstructQuery() throws Exception {
+ // Prepare
+ injectQueryEngine(null);
+
+ // Execute
+ graphAccess.executeSparqlQuery((ConstructQuery) null,
+ new SimpleMGraph());
+ }
+
+ @Test
+ public void executeSparqlQueryWithEngineWithString() throws Exception {
+ // Prepare
+ injectQueryEngine(queryEngine);
+ Graph Graph = new SimpleMGraph();
+
+ // Execute
+ graphAccess.executeSparqlQuery("", Graph);
+
+ // Verify
+ Mockito.verify(queryEngine).execute(graphAccess, Graph, "");
+// Mockito.verify(queryEngine, Mockito.never()).execute(
+// (TcManager) Mockito.anyObject(),
+// (Graph) Mockito.anyObject(),
+// Mockito.anyString());
+ }
+
+ @Test
+ public void executeSparqlQueryWithEngineWithSelectQuery() throws Exception {
+ // Prepare
+ injectQueryEngine(queryEngine);
+ Graph Graph = new SimpleMGraph();
+ SelectQuery query = Mockito.mock(SelectQuery.class);
+
+ // Execute
+ graphAccess.executeSparqlQuery(query, Graph);
+
+ // Verify
+ Mockito.verify(queryEngine).execute(graphAccess, Graph,
+ query.toString());
+// Mockito.verify(queryEngine, Mockito.never()).execute(
+// (TcManager) Mockito.anyObject(),
+// (Graph) Mockito.anyObject(), Mockito.anyString());
+ }
+
+ @Test
+ public void executeSparqlQueryWithEngineWithAskQuery() throws Exception {
+ // Prepare
+ injectQueryEngine(queryEngine);
+ Graph Graph = new SimpleMGraph();
+ AskQuery query = Mockito.mock(AskQuery.class);
+
+ Mockito.when(
+ queryEngine.execute((TcManager) Mockito.anyObject(),
+ (Graph) Mockito.anyObject(),
+ Mockito.anyString())).thenReturn(Boolean.TRUE);
+
+ // Execute
+ graphAccess.executeSparqlQuery(query, Graph);
+
+ // Verify
+ Mockito.verify(queryEngine).execute(graphAccess, Graph,
+ query.toString());
+// Mockito.verify(queryEngine, Mockito.never()).execute(
+// (TcManager) Mockito.anyObject(),
+// (Graph) Mockito.anyObject(), Mockito.anyString());
+ }
+
+ @Test
+ public void executeSparqlQueryWithEngineWithDescribeQuery()
+ throws Exception {
+ // Prepare
+ injectQueryEngine(queryEngine);
+ Graph Graph = new SimpleMGraph();
+ DescribeQuery query = Mockito.mock(DescribeQuery.class);
+
+ // Execute
+ graphAccess.executeSparqlQuery(query, Graph);
+
+ // Verify
+ Mockito.verify(queryEngine).execute(graphAccess, Graph,
+ query.toString());
+// Mockito.verify(queryEngine, Mockito.never()).execute(
+// (TcManager) Mockito.anyObject(),
+// (Graph) Mockito.anyObject(), Mockito.anyString());
+ }
+
+ @Test
+ public void executeSparqlQueryWithEngineWithConstructQuery()
+ throws Exception {
+ // Prepare
+ injectQueryEngine(queryEngine);
+ Graph Graph = new SimpleMGraph();
+ ConstructQuery query = Mockito.mock(ConstructQuery.class);
+
+ // Execute
+ graphAccess.executeSparqlQuery(query, Graph);
+
+ // Verify
+ Mockito.verify(queryEngine).execute(graphAccess, Graph,
+ query.toString());
+// Mockito.verify(queryEngine, Mockito.never()).execute(
+// (TcManager) Mockito.anyObject(),
+// (Graph) Mockito.anyObject(), Mockito.anyString());
+ }
+
+ // ------------------------------------------------------------------------
+ // Implementing QueryableTcProvider
+ // ------------------------------------------------------------------------
+
+ private void injectQueryEngine(QueryEngine engine)
+ throws NoSuchFieldException, IllegalAccessException {
+ Field queryEngineField = TcManager.class
+ .getDeclaredField("queryEngine");
+ queryEngineField.setAccessible(true);
+ queryEngineField.set(graphAccess, engine);
+ }
+}
\ No newline at end of file
diff --git a/dataset/src/test/java/org/apache/clerezza/dataset/providers/WeightedA.java b/dataset/src/test/java/org/apache/clerezza/dataset/providers/WeightedA.java
new file mode 100644
index 0000000..76b6f36
--- /dev/null
+++ b/dataset/src/test/java/org/apache/clerezza/dataset/providers/WeightedA.java
@@ -0,0 +1,103 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.clerezza.dataset.providers;
+
+import org.apache.clerezza.api.Graph;
+import org.apache.clerezza.api.IRI;
+import org.apache.clerezza.api.ImmutableGraph;
+import org.apache.clerezza.api.impl.TripleImpl;
+import org.apache.clerezza.api.impl.graph.SimpleMGraph;
+import org.apache.clerezza.dataset.EntityUndeletableException;
+import org.apache.clerezza.dataset.NoSuchEntityException;
+import org.apache.clerezza.dataset.TcManagerTest;
+import org.apache.clerezza.dataset.WeightedTcProvider;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ *
+ * @author reto
+ */
+public class WeightedA implements WeightedTcProvider {
+ private Set<IRI> mGraphList = new HashSet<IRI>();
+ @Override
+ public int getWeight() {
+ return 5;
+ }
+
+ @Override
+ public ImmutableGraph getImmutableGraph(IRI name) throws NoSuchEntityException {
+ if (name.equals(TcManagerTest.uriRefA)) {
+ Graph mResult = new SimpleMGraph();
+ mResult.add(new TripleImpl(TcManagerTest.uriRefA,
+ TcManagerTest.uriRefA, TcManagerTest.uriRefA));
+ mGraphList.add(name);
+ return mResult.getImmutableGraph();
+ }
+ throw new NoSuchEntityException(name);
+ }
+
+ @Override
+ public Graph getMGraph(IRI name) throws NoSuchEntityException {
+ throw new NoSuchEntityException(name);
+ }
+
+ @Override
+ public Graph getGraph(IRI name) throws NoSuchEntityException {
+ return getImmutableGraph(name);
+ }
+
+ @Override
+ public Graph createGraph(IRI name) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public ImmutableGraph createImmutableGraph(IRI name, Graph triples) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void deleteGraph(IRI name) throws NoSuchEntityException,
+ EntityUndeletableException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Set<IRI> getNames(ImmutableGraph ImmutableGraph) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Set<IRI> listGraphs() {
+ return Collections.singleton(TcManagerTest.uriRefA);
+ }
+
+ @Override
+ public Set<IRI> listMGraphs() {
+ return mGraphList;
+ }
+
+ @Override
+ public Set<IRI> listImmutableGraphs() {
+ return listGraphs();
+ }
+}
diff --git a/dataset/src/test/java/org/apache/clerezza/dataset/providers/WeightedA1.java b/dataset/src/test/java/org/apache/clerezza/dataset/providers/WeightedA1.java
new file mode 100644
index 0000000..effd599
--- /dev/null
+++ b/dataset/src/test/java/org/apache/clerezza/dataset/providers/WeightedA1.java
@@ -0,0 +1,103 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.clerezza.dataset.providers;
+
+import org.apache.clerezza.api.Graph;
+import org.apache.clerezza.api.IRI;
+import org.apache.clerezza.api.ImmutableGraph;
+import org.apache.clerezza.api.impl.TripleImpl;
+import org.apache.clerezza.api.impl.graph.SimpleMGraph;
+import org.apache.clerezza.dataset.EntityUndeletableException;
+import org.apache.clerezza.dataset.NoSuchEntityException;
+import org.apache.clerezza.dataset.TcManagerTest;
+import org.apache.clerezza.dataset.WeightedTcProvider;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * Same weight as WeightedA, but later in string-ordering
+ *
+ * @author reto
+ */
+public class WeightedA1 implements WeightedTcProvider {
+ private Set<IRI> mGraphList = new HashSet<IRI>();
+ @Override
+ public int getWeight() {
+ return 5;
+ }
+
+ @Override
+ public ImmutableGraph getImmutableGraph(IRI name) throws NoSuchEntityException {
+ if (name.equals(TcManagerTest.uriRefA)) {
+ Graph mResult = new SimpleMGraph();
+ mResult.add(new TripleImpl(TcManagerTest.uriRefA1,
+ TcManagerTest.uriRefA1, TcManagerTest.uriRefA1));
+ mGraphList.add(name);
+ return mResult.getImmutableGraph();
+ }
+ throw new NoSuchEntityException(name);
+ }
+
+ @Override
+ public Graph getMGraph(IRI name) throws NoSuchEntityException {
+ throw new NoSuchEntityException(name);
+ }
+
+ @Override
+ public Graph getGraph(IRI name) throws NoSuchEntityException {
+ return getImmutableGraph(name);
+ }
+
+ @Override
+ public Graph createGraph(IRI name) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public ImmutableGraph createImmutableGraph(IRI name, Graph triples) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void deleteGraph(IRI name) throws NoSuchEntityException,
+ EntityUndeletableException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Set<IRI> getNames(ImmutableGraph ImmutableGraph) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Set<IRI> listImmutableGraphs() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Set<IRI> listMGraphs() {
+ return mGraphList;
+ }
+
+ @Override
+ public Set<IRI> listGraphs() {
+ return listMGraphs();
+ }
+}
diff --git a/dataset/src/test/java/org/apache/clerezza/dataset/providers/WeightedAHeavy.java b/dataset/src/test/java/org/apache/clerezza/dataset/providers/WeightedAHeavy.java
new file mode 100644
index 0000000..3cc1421
--- /dev/null
+++ b/dataset/src/test/java/org/apache/clerezza/dataset/providers/WeightedAHeavy.java
@@ -0,0 +1,101 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.clerezza.dataset.providers;
+
+import org.apache.clerezza.api.Graph;
+import org.apache.clerezza.api.IRI;
+import org.apache.clerezza.api.ImmutableGraph;
+import org.apache.clerezza.api.impl.TripleImpl;
+import org.apache.clerezza.api.impl.graph.SimpleGraph;
+import org.apache.clerezza.dataset.EntityUndeletableException;
+import org.apache.clerezza.dataset.NoSuchEntityException;
+import org.apache.clerezza.dataset.TcManagerTest;
+import org.apache.clerezza.dataset.WeightedTcProvider;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ *
+ * @author reto
+ */
+public class WeightedAHeavy implements WeightedTcProvider {
+
+ @Override
+ public int getWeight() {
+ return 20;
+ }
+
+ @Override
+ public ImmutableGraph getImmutableGraph(IRI name) throws NoSuchEntityException {
+ if (name.equals(TcManagerTest.uriRefA)) {
+ Graph mResult = new SimpleGraph();
+ mResult.add(new TripleImpl(TcManagerTest.uriRefAHeavy,
+ TcManagerTest.uriRefAHeavy, TcManagerTest.uriRefAHeavy));
+ return mResult.getImmutableGraph();
+ }
+ throw new NoSuchEntityException(name);
+ }
+
+ @Override
+ public Graph getMGraph(IRI name) throws NoSuchEntityException {
+ throw new NoSuchEntityException(name);
+ }
+
+ @Override
+ public Graph getGraph(IRI name) throws NoSuchEntityException {
+ return getImmutableGraph(name);
+ }
+
+ @Override
+ public Graph createGraph(IRI name) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public ImmutableGraph createImmutableGraph(IRI name, Graph triples) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void deleteGraph(IRI name) throws NoSuchEntityException,
+ EntityUndeletableException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Set<IRI> getNames(ImmutableGraph ImmutableGraph) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+ @Override
+ public Set<IRI> listGraphs() {
+ return Collections.singleton(TcManagerTest.uriRefA);
+ }
+
+ @Override
+ public Set<IRI> listMGraphs() {
+ return new HashSet<IRI>();
+ }
+
+ @Override
+ public Set<IRI> listImmutableGraphs() {
+ return listGraphs();
+ }
+}
diff --git a/dataset/src/test/java/org/apache/clerezza/dataset/providers/WeightedBlight.java b/dataset/src/test/java/org/apache/clerezza/dataset/providers/WeightedBlight.java
new file mode 100644
index 0000000..161599b
--- /dev/null
+++ b/dataset/src/test/java/org/apache/clerezza/dataset/providers/WeightedBlight.java
@@ -0,0 +1,106 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.clerezza.dataset.providers;
+
+import org.apache.clerezza.api.Graph;
+import org.apache.clerezza.api.IRI;
+import org.apache.clerezza.api.ImmutableGraph;
+import org.apache.clerezza.api.impl.TripleImpl;
+import org.apache.clerezza.api.impl.graph.SimpleMGraph;
+import org.apache.clerezza.dataset.EntityUndeletableException;
+import org.apache.clerezza.dataset.NoSuchEntityException;
+import org.apache.clerezza.dataset.TcManagerTest;
+import org.apache.clerezza.dataset.WeightedTcProvider;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ *
+ * @author reto
+ */
+public class WeightedBlight implements WeightedTcProvider {
+
+ @Override
+ public int getWeight() {
+ return 2;
+ }
+
+ @Override
+ public ImmutableGraph getImmutableGraph(IRI name) throws NoSuchEntityException {
+ if (name.equals(TcManagerTest.uriRefB)) {
+ Graph mResult = new SimpleMGraph();
+ mResult.add(new TripleImpl(TcManagerTest.uriRefB, TcManagerTest.uriRefB, TcManagerTest.uriRefB));
+ return mResult.getImmutableGraph();
+ }
+ if (name.equals(TcManagerTest.uriRefA)) {
+ Graph mResult = new SimpleMGraph();
+ //empty ImmutableGraph
+ return mResult.getImmutableGraph();
+ }
+ throw new NoSuchEntityException(name);
+ }
+
+ @Override
+ public Graph getMGraph(IRI name) throws NoSuchEntityException {
+ throw new NoSuchEntityException(name);
+ }
+
+ @Override
+ public Graph getGraph(IRI name) throws NoSuchEntityException {
+ return getImmutableGraph(name);
+ }
+
+ @Override
+ public Graph createGraph(IRI name) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public ImmutableGraph createImmutableGraph(IRI name, Graph triples) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void deleteGraph(IRI name) throws NoSuchEntityException,
+ EntityUndeletableException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Set<IRI> getNames(ImmutableGraph ImmutableGraph) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Set<IRI> listImmutableGraphs() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Set<IRI> listMGraphs() {
+ return new HashSet<IRI>();
+ }
+
+ @Override
+ public Set<IRI> listGraphs() {
+ return listMGraphs();
+ }
+
+}
diff --git a/dataset/src/test/java/org/apache/clerezza/dataset/providers/WeightedDummy.java b/dataset/src/test/java/org/apache/clerezza/dataset/providers/WeightedDummy.java
new file mode 100644
index 0000000..44ace0e
--- /dev/null
+++ b/dataset/src/test/java/org/apache/clerezza/dataset/providers/WeightedDummy.java
@@ -0,0 +1,155 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.clerezza.dataset.providers;
+
+import org.apache.clerezza.api.Graph;
+import org.apache.clerezza.api.IRI;
+import org.apache.clerezza.api.ImmutableGraph;
+import org.apache.clerezza.api.impl.graph.SimpleImmutableGraph;
+import org.apache.clerezza.api.impl.graph.SimpleMGraph;
+import org.apache.clerezza.dataset.EntityAlreadyExistsException;
+import org.apache.clerezza.dataset.EntityUndeletableException;
+import org.apache.clerezza.dataset.NoSuchEntityException;
+import org.apache.clerezza.dataset.WeightedTcProvider;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ *
+ * @author mir
+ */
+public class WeightedDummy implements WeightedTcProvider {
+
+ private Map<IRI, Graph> tripleMap = new HashMap<IRI, Graph>();
+
+ @Override
+ public ImmutableGraph createImmutableGraph(IRI name, Graph triples)
+ throws EntityAlreadyExistsException {
+ if ((name == null) || (name.getUnicodeString() == null)
+ || (name.getUnicodeString().trim().length() == 0)) {
+ throw new IllegalArgumentException("Name must not be null");
+ }
+
+ try {
+ // throws NoSuchEntityException if a Graph with that name
+ // already exists
+ this.getGraph(name);
+ } catch (NoSuchEntityException e) {
+ ImmutableGraph result;
+ if (ImmutableGraph.class.isAssignableFrom(triples.getClass())) {
+ result = (ImmutableGraph) triples;
+ } else {
+ result = new SimpleImmutableGraph(triples);
+ }
+ tripleMap.put(name, result);
+
+ return result;
+ }
+ throw new EntityAlreadyExistsException(name);
+ }
+
+ @Override
+ public Graph createGraph(IRI name) throws EntityAlreadyExistsException {
+ if ((name == null) || (name.getUnicodeString() == null)
+ || (name.getUnicodeString().trim().length() == 0)) {
+ throw new IllegalArgumentException("Name must not be null");
+ }
+
+ try {
+ // throws NoSuchEntityException if a Graph with that name
+ // already exists
+ this.getGraph(name);
+ } catch (NoSuchEntityException e) {
+ Graph result = new SimpleMGraph();
+ tripleMap.put(name, result);
+ return result;
+ }
+ throw new EntityAlreadyExistsException(name);
+ }
+
+ @Override
+ public void deleteGraph(IRI name)
+ throws NoSuchEntityException, EntityUndeletableException {
+ if (tripleMap.remove(name) == null) {
+ throw new NoSuchEntityException(name);
+ }
+ }
+
+ @Override
+ public ImmutableGraph getImmutableGraph(IRI name) throws NoSuchEntityException {
+ Graph Graph = tripleMap.get(name);
+ if (Graph == null) {
+ throw new NoSuchEntityException(name);
+ } else if (ImmutableGraph.class.isAssignableFrom(Graph.getClass())) {
+ return (ImmutableGraph) Graph;
+ }
+ throw new NoSuchEntityException(name);
+ }
+
+ @Override
+ public Graph getMGraph(IRI name) throws NoSuchEntityException {
+ Graph Graph = tripleMap.get(name);
+ if (Graph == null) {
+ throw new NoSuchEntityException(name);
+ } else if (Graph.class.isAssignableFrom(Graph.getClass())) {
+ return (Graph) Graph;
+ }
+ throw new NoSuchEntityException(name);
+ }
+
+ @Override
+ public Set<IRI> getNames(ImmutableGraph ImmutableGraph) {
+ throw new UnsupportedOperationException(
+ "Not supported yet. equals() has to be implemented first");
+ }
+
+ @Override
+ public Graph getGraph(IRI name)
+ throws NoSuchEntityException {
+ Graph Graph = tripleMap.get(name);
+ if (Graph == null) {
+ throw new NoSuchEntityException(name);
+ } else {
+ return Graph;
+ }
+ }
+
+ @Override
+ public int getWeight() {
+ return 1;
+ }
+
+ @Override
+ public Set<IRI> listImmutableGraphs() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Set<IRI> listMGraphs() {
+ return new HashSet<IRI>();
+ }
+
+ @Override
+ public Set<IRI> listGraphs() {
+ return listMGraphs();
+ }
+}