package org.neo4j.rdf.sail.rmi;
import java.rmi.RemoteException;
import java.rmi.server.RMIClientSocketFactory;
import java.rmi.server.RMIServerSocketFactory;
import java.rmi.server.UnicastRemoteObject;
import java.rmi.server.Unreferenced;
import java.util.Map;
import org.neo4j.rdf.sail.FulltextQueryResult;
import org.neo4j.rdf.sail.GraphDatabaseSailConnection;
import org.neo4j.rdf.sail.rmi.RmiSailServer.RmiSailConnectionFactory;
import org.openrdf.model.Literal;
import org.openrdf.model.Namespace;
import org.openrdf.model.Resource;
import org.openrdf.model.Statement;
import org.openrdf.model.URI;
import org.openrdf.model.Value;
import org.openrdf.query.BindingSet;
import org.openrdf.query.Dataset;
import org.openrdf.query.QueryEvaluationException;
import org.openrdf.query.algebra.TupleExpr;
import org.openrdf.sail.SailConnection;
import org.openrdf.sail.SailException;
class RmiSailConnectionImpl extends UnicastRemoteObject
implements RmiSailConnection, Unreferenced
{
private final SailConnection connection;
private final RmiSailConnectionFactory factory;
private boolean connected = true;
RmiSailConnectionImpl( SailConnection connection,
RmiSailConnectionFactory factory ) throws RemoteException
{
super();
this.connection = connection;
this.factory = factory;
}
RmiSailConnectionImpl( SailConnection connection,
RmiSailConnectionFactory factory, int port ) throws RemoteException
{
super( port );
this.connection = connection;
this.factory = factory;
}
RmiSailConnectionImpl( SailConnection connection,
RmiSailConnectionFactory factory, int port, RMIClientSocketFactory csf,
RMIServerSocketFactory ssf ) throws RemoteException
{
super( port, csf, ssf );
this.connection = connection;
this.factory = factory;
}
void callbackConnectionLost()
{
// Assume that the connection is lost in the incoming direction as well
unreferenced();
}
public void unreferenced()
{
if ( connected )
{
try
{
if ( connection.isOpen() )
{
connection.close();
}
}
catch ( SailException se )
{
// Nothing we can do about it
}
connected = false;
}
}
// Implementation
public void addStatement( Resource subj, URI pred, Value obj,
Resource[] contexts ) throws SailException
{
connection.addStatement( subj, pred, obj, contexts );
}
public Statement addStatement( Map<String, Literal> metadata, Resource subj,
URI pred, Value obj, Resource[] contexts ) throws SailException
{
return getSailConnection().addStatement( metadata, subj, pred, obj,
contexts );
}
public void clear( Resource[] contexts ) throws SailException
{
connection.clear( contexts );
}
public void clearNamespaces() throws SailException
{
connection.clearNamespaces();
}
public void close() throws SailException
{
connection.close();
connected = false;
}
public void commit() throws SailException
{
connection.commit();
}
public String getNamespace( String prefix ) throws SailException
{
return connection.getNamespace( prefix );
}
public boolean isOpen() throws SailException
{
return connection.isOpen();
}
public void removeNamespace( String prefix ) throws SailException
{
connection.removeNamespace( prefix );
}
public void removeStatements( Resource subj, URI pred, Value obj,
Resource[] contexts ) throws SailException
{
connection.removeStatements( subj, pred, obj, contexts );
}
public void rollback() throws SailException
{
connection.rollback();
}
public void setNamespace( String prefix, String name ) throws SailException
{
connection.setNamespace( prefix, name );
}
public long size( Resource[] contexts ) throws SailException
{
return connection.size( contexts );
}
public RmiIterationBuffer<? extends BindingSet, QueryEvaluationException> evaluate(
TupleExpr tupleExpr, Dataset dataset, BindingSet bindings,
boolean includeInferred ) throws SailException, RemoteException
{
return factory.buffer( connection.evaluate( tupleExpr, dataset,
bindings, includeInferred ) );
}
public RmiIterationBuffer<? extends Resource, SailException> getContextIDs()
throws SailException, RemoteException
{
return factory.buffer( connection.getContextIDs() );
}
public RmiIterationBuffer<? extends Namespace, SailException> getNamespaces()
throws SailException, RemoteException
{
return factory.buffer( connection.getNamespaces() );
}
public RmiIterationBuffer<? extends Statement, SailException> getStatements(
Resource subj, URI pred, Value obj, boolean includeInferred,
Resource[] contexts ) throws SailException, RemoteException
{
return factory.buffer( connection.getStatements( subj, pred, obj,
includeInferred, contexts ) );
}
private GraphDatabaseSailConnection getSailConnection()
{
if ( !( connection instanceof GraphDatabaseSailConnection ) )
{
throw new RuntimeException( "Only available for connections " +
"implementing " + GraphDatabaseSailConnection.class );
}
return ( GraphDatabaseSailConnection ) connection;
}
public RmiIterationBuffer<? extends FulltextQueryResult, SailException> evaluate(
String query ) throws SailException, RemoteException
{
GraphDatabaseSailConnection sailCollection = getSailConnection();
return factory.buffer( sailCollection.evaluate( query ) );
}
public RmiIterationBuffer<? extends FulltextQueryResult, SailException>
evaluateWithSnippets( String query, int snippetCountLimit )
throws SailException, RemoteException
{
GraphDatabaseSailConnection sailCollection = getSailConnection();
return factory.buffer( sailCollection.evaluateWithSnippets(
query, snippetCountLimit ) );
}
public void setStatementMetadata( Statement statement,
Map<String, Literal> metadata ) throws SailException, RemoteException
{
GraphDatabaseSailConnection sailCollection = getSailConnection();
sailCollection.setStatementMetadata( statement, metadata );
}
public void reindexFulltextIndex() throws SailException, RemoteException
{
getSailConnection().reindexFulltextIndex();
}
}