Merge pull request #871 from jamesrdf/issues/#870-repo-mgr-sail

Fix #870: Move classes around to avoid SAIL dependency on RepositoryManager

Author: James Leigh

compliance/http/pom.xml

@@ -92,6 +92,20 @@
 			<version>${project.version}</version>
 		</dependency>
 
+		<dependency>
+			<groupId>${project.groupId}</groupId>
+			<artifactId>rdf4j-repository-sail</artifactId>
+			<version>${project.version}</version>
+			<scope>test</scope>
+		</dependency>
+
+		<dependency>
+			<groupId>${project.groupId}</groupId>
+			<artifactId>rdf4j-sail-memory</artifactId>
+			<version>${project.version}</version>
+			<scope>test</scope>
+		</dependency>
+
 		<dependency>
 			<groupId>${project.groupId}</groupId>
 			<artifactId>rdf4j-config</artifactId>

core/queryalgebra/evaluation/src/main/java/org/eclipse/rdf4j/query/algebra/evaluation/EvaluationStrategy.java

@@ -16,7 +16,7 @@
 import org.eclipse.rdf4j.query.algebra.ValueExpr;
 import org.eclipse.rdf4j.query.algebra.evaluation.federation.FederatedService;
 import org.eclipse.rdf4j.query.algebra.evaluation.federation.FederatedServiceResolver;
-import org.eclipse.rdf4j.query.algebra.evaluation.federation.SPARQLFederatedService;
+import org.eclipse.rdf4j.repository.sparql.federation.SPARQLFederatedService;
 
 /**
  * Evaluates {@link TupleExpr}s and {@link ValueExpr}s.

core/queryalgebra/evaluation/src/main/java/org/eclipse/rdf4j/query/algebra/evaluation/federation/FederatedServiceResolverImpl.java

@@ -7,13 +7,6 @@
  *******************************************************************************/
 package org.eclipse.rdf4j.query.algebra.evaluation.federation;
 
-import org.apache.http.client.HttpClient;
-import org.eclipse.rdf4j.http.client.HttpClientDependent;
-import org.eclipse.rdf4j.http.client.HttpClientSessionManager;
-import org.eclipse.rdf4j.http.client.SessionManagerDependent;
-import org.eclipse.rdf4j.http.client.SharedHttpClientSessionManager;
-import org.eclipse.rdf4j.query.QueryEvaluationException;
-
 /**
  * The {@link FederatedServiceResolverImpl} is used to manage a set of {@link FederatedService} instances,
  * which are used to evaluate SERVICE expressions for particular service Urls.
@@ -23,78 +16,11 @@
  * 
  * @author Andreas Schwarte
  * @author James Leigh
+ * @deprecated since 2.3 use
+ *             {@link org.eclipse.rdf4j.repository.sparql.federation.SPARQLServiceResolver}
  */
-public class FederatedServiceResolverImpl extends AbstractFederatedServiceResolver
-		implements FederatedServiceResolver, HttpClientDependent, SessionManagerDependent
+@Deprecated
+public class FederatedServiceResolverImpl
+		extends org.eclipse.rdf4j.repository.sparql.federation.SPARQLServiceResolver
 {
-
-	public FederatedServiceResolverImpl() {
-		super();
-	}
-
-	/** independent life cycle */
-	private volatile HttpClientSessionManager client;
-
-	/** dependent life cycle */
-	private volatile SharedHttpClientSessionManager dependentClient;
-
-	public HttpClientSessionManager getHttpClientSessionManager() {
-		HttpClientSessionManager result = client;
-		if (result == null) {
-			synchronized (this) {
-				result = client;
-				if (result == null) {
-					result = client = dependentClient = new SharedHttpClientSessionManager();
-				}
-			}
-		}
-		return result;
-	}
-
-	public void setHttpClientSessionManager(HttpClientSessionManager client) {
-		synchronized (this) {
-			this.client = client;
-			// If they set a client, we need to check whether we need to
-			// shutdown any existing dependentClient
-			SharedHttpClientSessionManager toCloseDependentClient = dependentClient;
-			dependentClient = null;
-			if (toCloseDependentClient != null) {
-				toCloseDependentClient.shutDown();
-			}
-		}
-	}
-
-	public HttpClient getHttpClient() {
-		return getHttpClientSessionManager().getHttpClient();
-	}
-
-	public void setHttpClient(HttpClient httpClient) {
-		SharedHttpClientSessionManager toSetDependentClient = dependentClient;
-		if (toSetDependentClient == null) {
-			getHttpClientSessionManager();
-			toSetDependentClient = dependentClient;
-		}
-		// The strange lifecycle results in the possibility that the
-		// dependentClient will be null due to a call to setSesameClient, so add
-		// a null guard here for that possibility
-		if (toSetDependentClient != null) {
-			toSetDependentClient.setHttpClient(httpClient);
-		}
-	}
-
-	@Override
-	protected FederatedService createService(String serviceUrl)
-		throws QueryEvaluationException
-	{
-		return new SPARQLFederatedService(serviceUrl, getHttpClientSessionManager());
-	}
-
-	@Override
-	public void shutDown() {
-		super.shutDown();
-		if (dependentClient != null) {
-			dependentClient.shutDown();
-			dependentClient = null;
-		}
-	}
 }

core/queryalgebra/evaluation/src/main/java/org/eclipse/rdf4j/query/algebra/evaluation/federation/JoinExecutorBase.java

@@ -7,11 +7,8 @@
  *******************************************************************************/
 package org.eclipse.rdf4j.query.algebra.evaluation.federation;
 
-import org.eclipse.rdf4j.common.iteration.AbstractCloseableIteration;
 import org.eclipse.rdf4j.common.iteration.CloseableIteration;
-import org.eclipse.rdf4j.common.iteration.EmptyIteration;
 import org.eclipse.rdf4j.common.iteration.LookAheadIteration;
-import org.eclipse.rdf4j.http.client.QueueCursor;
 import org.eclipse.rdf4j.query.BindingSet;
 import org.eclipse.rdf4j.query.QueryEvaluationException;
 import org.eclipse.rdf4j.query.algebra.TupleExpr;
@@ -22,159 +19,17 @@
  * to shared variables is synchronized).
  * 
  * @author Andreas Schwarte
+ * @deprecated since 2.3 use {@link org.eclipse.rdf4j.repository.sparql.federation.JoinExecutorBase}
  */
-public abstract class JoinExecutorBase<T> extends LookAheadIteration<T, QueryEvaluationException> {
-
-	/**
-	 * @deprecated No replacement, don't use static shared int variables.
-	 */
-	protected static int NEXT_JOIN_ID = 1;
-
-	/* Constants */
-	protected final TupleExpr rightArg; // the right argument for the join
-
-	protected final BindingSet bindings; // the bindings
-
-	protected final CloseableIteration<T, QueryEvaluationException> leftIter;
-
-	protected volatile CloseableIteration<T, QueryEvaluationException> rightIter;
-
-	/**
-	 * @deprecated Use {@link AbstractCloseableIteration#isClosed()} instead.
-	 */
-	protected volatile boolean closed = false;
-
-	/**
-	 * @deprecated Use {@link #isFinished()} instead.
-	 */
-	protected volatile boolean finished = false;
-
-	protected final QueueCursor<CloseableIteration<T, QueryEvaluationException>> rightQueue = new QueueCursor<CloseableIteration<T, QueryEvaluationException>>(
-			1024);
+@Deprecated
+public abstract class JoinExecutorBase<T>
+		extends org.eclipse.rdf4j.repository.sparql.federation.JoinExecutorBase<T>
+{
 
 	public JoinExecutorBase(CloseableIteration<T, QueryEvaluationException> leftIter, TupleExpr rightArg,
 			BindingSet bindings)
 		throws QueryEvaluationException
 	{
-		this.leftIter = leftIter;
-		this.rightArg = rightArg;
-		this.bindings = bindings;
+		super(leftIter, rightArg, bindings);
 	}
-
-	public final void run() {
-
-		try {
-			handleBindings();
-		}
-		catch (Exception e) {
-			toss(e);
-		}
-		finally {
-			finished = true;
-			rightQueue.done();
-		}
-
-	}
-
-	/**
-	 * Implementations must implement this method to handle bindings. Use the following as a template <code>
-	 * while (!closed && leftIter.hasNext()) {
-	 * 		// your code
-	 * }
-	 * </code> and add results to rightQueue. Note that addResult() is implemented synchronized and thus
-	 * thread safe. In case you can guarantee sequential access, it is also possible to directly access
-	 * rightQueue
-	 */
-	protected abstract void handleBindings()
-		throws Exception;
-
-	public void addResult(CloseableIteration<T, QueryEvaluationException> res) {
-		/* optimization: avoid adding empty results */
-		if (res instanceof EmptyIteration<?, ?>) {
-			return;
-		}
-
-		try {
-			rightQueue.put(res);
-		}
-		catch (InterruptedException e) {
-			Thread.currentThread().interrupt();
-			throw new RuntimeException("Error adding element to right queue", e);
-		}
-	}
-
-	public void done() {
-		; // no-op
-	}
-
-	public void toss(Exception e) {
-		rightQueue.toss(e);
-	}
-
-	@Override
-	public T getNextElement()
-		throws QueryEvaluationException
-	{
-		// TODO check if we need to protect rightQueue from synchronized access
-		// wasn't done in the original implementation either
-		// if we see any weird behavior check here !!
-
-		while (rightIter != null || rightQueue.hasNext()) {
-			CloseableIteration<T, QueryEvaluationException> nextRightIter = rightIter;
-			if (nextRightIter == null) {
-				nextRightIter = rightIter = rightQueue.next();
-			}
-			if (nextRightIter != null) {
-				if (nextRightIter.hasNext()) {
-					return nextRightIter.next();
-				}
-				else {
-					rightIter = null;
-					nextRightIter.close();
-				}
-			}
-		}
-
-		return null;
-	}
-
-	@Override
-	public void handleClose()
-		throws QueryEvaluationException
-	{
-		closed = true;
-		try {
-			super.handleClose();
-		}
-		finally {
-			try {
-				rightQueue.close();
-			}
-			finally {
-				try {
-					CloseableIteration<T, QueryEvaluationException> toCloseRightIter = rightIter;
-					rightIter = null;
-					if (toCloseRightIter != null) {
-						toCloseRightIter.close();
-					}
-				}
-				finally {
-					CloseableIteration<T, QueryEvaluationException> toCloseLeftIter = leftIter;
-					if (toCloseLeftIter != null) {
-						toCloseLeftIter.close();
-					}
-				}
-			}
-		}
-	}
-
-	/**
-	 * Gets whether this executor is finished or aborted.
-	 * 
-	 * @return true if this executor is finished or aborted
-	 */
-	public boolean isFinished() {
-		return finished;
-	}
-
 }