Thread: [Bigdata-commit] SF.net SVN: bigdata:[8501] branches/BIGDATA_RELEASE_1_3_0 (Page 6)

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

Revision: 8501
          http://sourceforge.net/p/bigdata/code/8501
Author:   thompsonbry
Date:     2014-06-17 21:14:25 +0000 (Tue, 17 Jun 2014)
Log Message:
-----------
Continued progress in support of #566 and #753. I am iterating over the REST API method implementations and restructuring them to support both #566 and, by extension, #753 as well. It is not necessary to change over to group commit in order to derive the benefit from this refactoring, but when we do change over it will be with a single boolean switch from the existing operational mode to the group commit operational mode.

I have modified the code to execute the RestApiTask in the caller's thread for the non-group-commit code path. This avoids the potential introduction of another thread for heavy query workloads.

I have cleaned up some of the launderThrowable() invocations to provide better information about the REST API request that failed.  This is not yet systematic.

SPARQL Query and SPARQL UPDATE now go through the RestApiTask pattern.

Continuing to identify, document, and work through potential problems in the REST API that would conflict with group commit semantics.

All tests are passing. Group commit is still disabled.

Modified Paths:
--------------
    branches/BIGDATA_RELEASE_1_3_0/bigdata/src/java/com/bigdata/BigdataStatics.java
    branches/BIGDATA_RELEASE_1_3_0/bigdata-sails/src/java/com/bigdata/rdf/sail/webapp/BigdataRDFContext.java
    branches/BIGDATA_RELEASE_1_3_0/bigdata-sails/src/java/com/bigdata/rdf/sail/webapp/BigdataRDFServlet.java
    branches/BIGDATA_RELEASE_1_3_0/bigdata-sails/src/java/com/bigdata/rdf/sail/webapp/BigdataServlet.java
    branches/BIGDATA_RELEASE_1_3_0/bigdata-sails/src/java/com/bigdata/rdf/sail/webapp/BlueprintsServlet.java
    branches/BIGDATA_RELEASE_1_3_0/bigdata-sails/src/java/com/bigdata/rdf/sail/webapp/DeleteServlet.java
    branches/BIGDATA_RELEASE_1_3_0/bigdata-sails/src/java/com/bigdata/rdf/sail/webapp/DescribeCacheServlet.java
    branches/BIGDATA_RELEASE_1_3_0/bigdata-sails/src/java/com/bigdata/rdf/sail/webapp/InsertServlet.java
    branches/BIGDATA_RELEASE_1_3_0/bigdata-sails/src/java/com/bigdata/rdf/sail/webapp/MultiTenancyServlet.java
    branches/BIGDATA_RELEASE_1_3_0/bigdata-sails/src/java/com/bigdata/rdf/sail/webapp/QueryServlet.java
    branches/BIGDATA_RELEASE_1_3_0/bigdata-sails/src/java/com/bigdata/rdf/sail/webapp/RESTServlet.java
    branches/BIGDATA_RELEASE_1_3_0/bigdata-sails/src/java/com/bigdata/rdf/sail/webapp/RestApiTask.java
    branches/BIGDATA_RELEASE_1_3_0/bigdata-sails/src/java/com/bigdata/rdf/sail/webapp/StatusServlet.java
    branches/BIGDATA_RELEASE_1_3_0/bigdata-sails/src/java/com/bigdata/rdf/sail/webapp/UpdateServlet.java

Modified: branches/BIGDATA_RELEASE_1_3_0/bigdata/src/java/com/bigdata/BigdataStatics.java
===================================================================

--- branches/BIGDATA_RELEASE_1_3_0/bigdata/src/java/com/bigdata/BigdataStatics.java	2014-06-17 20:51:10 UTC (rev 8500)
+++ branches/BIGDATA_RELEASE_1_3_0/bigdata/src/java/com/bigdata/BigdataStatics.java	2014-06-17 21:14:25 UTC (rev 8501)
@@ -125,7 +125,6 @@
      * @see <a href="- http://sourceforge.net/apps/trac/bigdata/ticket/566" >
      *      Concurrent unisolated operations against multiple KBs </a>
      */
-    public static final boolean NSS_GROUP_COMMIT = Boolean
-            .getBoolean("com.bigdata.nssGroupCommit");
+    public static final boolean NSS_GROUP_COMMIT = Boolean.getBoolean("com.bigdata.nssGroupCommit");
 
 }

Modified: branches/BIGDATA_RELEASE_1_3_0/bigdata-sails/src/java/com/bigdata/rdf/sail/webapp/BigdataRDFContext.java
===================================================================
--- branches/BIGDATA_RELEASE_1_3_0/bigdata-sails/src/java/com/bigdata/rdf/sail/webapp/BigdataRDFContext.java	2014-06-17 20:51:10 UTC (rev 8500)
+++ branches/BIGDATA_RELEASE_1_3_0/bigdata-sails/src/java/com/bigdata/rdf/sail/webapp/BigdataRDFContext.java	2014-06-17 21:14:25 UTC (rev 8501)
@@ -95,6 +95,7 @@
 import com.bigdata.rdf.sail.ISPARQLUpdateListener;
 import com.bigdata.rdf.sail.SPARQLUpdateEvent;
 import com.bigdata.rdf.sail.sparql.Bigdata2ASTSPARQLParser;
+import com.bigdata.rdf.sail.webapp.RestApiTask.RestApiMutationTask;
 import com.bigdata.rdf.sail.webapp.client.StringUtil;
 import com.bigdata.rdf.sparql.ast.ASTContainer;
 import com.bigdata.rdf.sparql.ast.QueryHints;
@@ -365,13 +366,10 @@
     /**
      * Immediate shutdown interrupts any running queries.
      * 
-     * FIXME Must abort any open transactions. This does not matter for the
-     * standalone database, but it will make a difference in scale-out. The
-     * transaction identifiers could be obtained from the {@link #queries} map.
-     * 
-     * FIXME This must also abort any running updates. Those are currently
-     * running in thread handling the {@link HttpServletRequest}, however it
-     * probably makes sense to execute them on a bounded thread pool as well.
+     * FIXME GROUP COMMIT: Shutdown should abort open transactions (including
+     * queries and updates). This hould be addressed when we handle group commit
+     * since that provides us with a means to recognize and interrupt each
+     * running {@link RestApiTask}.
      */
     void shutdownNow() {
 
@@ -1135,83 +1133,125 @@
         abstract protected void doQuery(BigdataSailRepositoryConnection cxn,
                 OutputStream os) throws Exception;
 
-        @Override
-        final public Void call() throws Exception {
-			BigdataSailRepositoryConnection cxn = null;
-			boolean success = false;
-            try {
-                // Note: Will be UPDATE connection if UPDATE request!!!
-                cxn = getQueryConnection(namespace, timestamp);
-                if(log.isTraceEnabled())
-                    log.trace("Query running...");
-                beginNanos = System.nanoTime();
-                if (explain && !update) {
-                    /*
-                     * The data goes to a bit bucket and we send an
-                     * "explanation" of the query evaluation back to the caller.
-                     * 
-                     * Note: The trick is how to get hold of the IRunningQuery
-                     * object. It is created deep within the Sail when we
-                     * finally submit a query plan to the query engine. We have
-                     * the queryId (on queryId2), so we can look up the
-                     * IRunningQuery in [m_queries] while it is running, but
-                     * once it is terminated the IRunningQuery will have been
-                     * cleared from the internal map maintained by the
-                     * QueryEngine, at which point we can not longer find it.
-                     * 
-                     * Note: We can't do this for UPDATE since it would have a
-                     * side-effect anyway. The way to "EXPLAIN" an UPDATE is to
-                     * break it down into the component QUERY bits and execute
-                     * those.
-                     */
-                    doQuery(cxn, new NullOutputStream());
-                    success = true;
-                } else {
-                    doQuery(cxn, os);
-                    success = true;
-                    os.flush();
-                    os.close();
-                }
-                if (log.isTraceEnabled())
-                    log.trace("Query done.");
-                return null;
-            } finally {
-                endNanos = System.nanoTime();
-                m_queries.remove(queryId);
-                if (queryId2 != null) m_queries2.remove(queryId2);
-//                if (os != null) {
-//                    try {
-//                        os.close();
-//                    } catch (Throwable t) {
-//                        log.error(t, t);
-//                    }
-//                }
-                if (cxn != null) {
-                    if (!success && !cxn.isReadOnly()) {
+        /**
+         * Task for executing a SPARQL QUERY or SPARQL UPDATE.
+         * <p>
+         * See {@link AbstractQueryTask#update} to decide whether this task is a
+         * QUERY or an UPDATE.
+         * 
+         * @author <a href="mailto:tho...@us...">Bryan
+         *         Thompson</a>
+         */
+        private class SparqlRestApiTask extends RestApiTask<Void> {
+
+            public SparqlRestApiTask(final HttpServletRequest req,
+                    final HttpServletResponse resp, final String namespace,
+                    final long timestamp) {
+
+                super(req, resp, namespace, timestamp);
+                
+            }
+
+            @Override
+            public Void call() throws Exception {
+                BigdataSailRepositoryConnection cxn = null;
+                boolean success = false;
+                try {
+                    // Note: Will be UPDATE connection if UPDATE request!!!
+                    cxn = getQueryConnection();//namespace, timestamp);
+                    if(log.isTraceEnabled())
+                        log.trace("Query running...");
+                    beginNanos = System.nanoTime();
+                    if (explain && !update) {
                         /*
-                         * Force rollback of the connection.
+                         * The data goes to a bit bucket and we send an
+                         * "explanation" of the query evaluation back to the caller.
                          * 
-                         * Note: It is possible that the commit has already been
-                         * processed, in which case this rollback() will be a
-                         * NOP. This can happen when there is an IO error when
-                         * communicating with the client, but the database has
-                         * already gone through a commit.
+                         * Note: The trick is how to get hold of the IRunningQuery
+                         * object. It is created deep within the Sail when we
+                         * finally submit a query plan to the query engine. We have
+                         * the queryId (on queryId2), so we can look up the
+                         * IRunningQuery in [m_queries] while it is running, but
+                         * once it is terminated the IRunningQuery will have been
+                         * cleared from the internal map maintained by the
+                         * QueryEngine, at which point we can not longer find it.
+                         * 
+                         * Note: We can't do this for UPDATE since it would have a
+                         * side-effect anyway. The way to "EXPLAIN" an UPDATE is to
+                         * break it down into the component QUERY bits and execute
+                         * those.
                          */
+                        doQuery(cxn, new NullOutputStream());
+                        success = true;
+                    } else {
+                        doQuery(cxn, os);
+                        success = true;
+                        os.flush();
+                        os.close();
+                    }
+                    if (log.isTraceEnabled())
+                        log.trace("Query done.");
+                    return null;
+                } finally {
+                    endNanos = System.nanoTime();
+                    m_queries.remove(queryId);
+                    if (queryId2 != null) m_queries2.remove(queryId2);
+//                    if (os != null) {
+//                        try {
+//                            os.close();
+//                        } catch (Throwable t) {
+//                            log.error(t, t);
+//                        }
+//                    }
+                    if (cxn != null) {
+                        if (!success && !cxn.isReadOnly()) {
+                            /*
+                             * Force rollback of the connection.
+                             * 
+                             * Note: It is possible that the commit has already been
+                             * processed, in which case this rollback() will be a
+                             * NOP. This can happen when there is an IO error when
+                             * communicating with the client, but the database has
+                             * already gone through a commit.
+                             */
+                            try {
+                                // Force rollback of the connection.
+                                cxn.rollback();
+                            } catch (Throwable t) {
+                                log.error(t, t);
+                            }
+                        }
                         try {
-                            // Force rollback of the connection.
-                            cxn.rollback();
+                            // Force close of the connection.
+                            cxn.close();
                         } catch (Throwable t) {
                             log.error(t, t);
                         }
                     }
-                    try {
-                        // Force close of the connection.
-                        cxn.close();
-                    } catch (Throwable t) {
-                        log.error(t, t);
-                    }
                 }
             }
+            
+        }
+        
+        @Override
+        final public Void call() throws Exception {
+            
+            final String queryOrUpdateStr = astContainer.getQueryString();
+            
+            try {
+                
+                return BigdataServlet.submitApiTask(getIndexManager(),
+                        new SparqlRestApiTask(req, resp, namespace, timestamp))
+                        .get();
+
+            } catch (Throwable t) {
+
+                // FIXME GROUP_COMMIT: check calling stack for existing launderThrowable.
+                throw BigdataRDFServlet.launderThrowable(t, resp,
+                        queryOrUpdateStr);
+
+            }
+
         } // call()
 
     } // class AbstractQueryTask
@@ -1234,6 +1274,7 @@
 
         }
 
+        @Override
         protected void doQuery(final BigdataSailRepositoryConnection cxn,
                 final OutputStream os) throws Exception {
 
@@ -2111,64 +2152,64 @@
 
 	}
 
-    /**
-     * Return a connection transaction, which may be read-only or support
-     * update. When the timestamp is associated with a historical commit point,
-     * this will be a read-only connection. When it is associated with the
-     * {@link ITx#UNISOLATED} view or a read-write transaction, this will be a
-     * mutable connection.
-     * 
-     * @param namespace
-     *            The namespace.
-     * @param timestamp
-     *            The timestamp.
-     * 
-     * @throws RepositoryException
-     */
-    public BigdataSailRepositoryConnection getQueryConnection(
-            final String namespace, final long timestamp)
-            throws RepositoryException {
+//    /**
+//     * Return a connection transaction, which may be read-only or support
+//     * update. When the timestamp is associated with a historical commit point,
+//     * this will be a read-only connection. When it is associated with the
+//     * {@link ITx#UNISOLATED} view or a read-write transaction, this will be a
+//     * mutable connection.
+//     * 
+//     * @param namespace
+//     *            The namespace.
+//     * @param timestamp
+//     *            The timestamp.
+//     * 
+//     * @throws RepositoryException
+//     */
+//    public BigdataSailRepositoryConnection getQueryConnection(
+//            final String namespace, final long timestamp)
+//            throws RepositoryException {
+//
+//        /*
+//         * Note: [timestamp] will be a read-only tx view of the triple store if
+//         * a READ_LOCK was specified when the NanoSparqlServer was started
+//         * (unless the query explicitly overrides the timestamp of the view on
+//         * which it will operate).
+//         */
+//        final AbstractTripleStore tripleStore = getTripleStore(namespace,
+//                timestamp);
+//        
+//        if (tripleStore == null) {
+//
+//            throw new DatasetNotFoundException("Not found: namespace="
+//                    + namespace + ", timestamp="
+//                    + TimestampUtility.toString(timestamp));
+//
+//        }
+//        
+//        // Wrap with SAIL.
+//        final BigdataSail sail = new BigdataSail(tripleStore);
+//
+//        final BigdataSailRepository repo = new BigdataSailRepository(sail);
+//
+//        repo.initialize();
+//
+//        if (TimestampUtility.isReadOnly(timestamp)) {
+//
+//            return (BigdataSailRepositoryConnection) repo
+//                    .getReadOnlyConnection(timestamp);
+//
+//        }
+//        
+//        // Read-write connection.
+//        final BigdataSailRepositoryConnection conn = repo.getConnection();
+//        
+//        conn.setAutoCommit(false);
+//        
+//        return conn;
+//
+//    }
 
-        /*
-         * Note: [timestamp] will be a read-only tx view of the triple store if
-         * a READ_LOCK was specified when the NanoSparqlServer was started
-         * (unless the query explicitly overrides the timestamp of the view on
-         * which it will operate).
-         */
-        final AbstractTripleStore tripleStore = getTripleStore(namespace,
-                timestamp);
-        
-        if (tripleStore == null) {
-
-            throw new DatasetNotFoundException("Not found: namespace="
-                    + namespace + ", timestamp="
-                    + TimestampUtility.toString(timestamp));
-
-        }
-        
-        // Wrap with SAIL.
-        final BigdataSail sail = new BigdataSail(tripleStore);
-
-        final BigdataSailRepository repo = new BigdataSailRepository(sail);
-
-        repo.initialize();
-
-        if (TimestampUtility.isReadOnly(timestamp)) {
-
-            return (BigdataSailRepositoryConnection) repo
-                    .getReadOnlyConnection(timestamp);
-
-        }
-        
-        // Read-write connection.
-        final BigdataSailRepositoryConnection conn = repo.getConnection();
-        
-        conn.setAutoCommit(false);
-        
-        return conn;
-
-    }
-
     /**
      * Return a read-only view of the {@link AbstractTripleStore} for the given
      * namespace will read from the commit point associated with the given
@@ -2182,12 +2223,17 @@
      * @return The {@link AbstractTripleStore} -or- <code>null</code> if none is
      *         found for that namespace and timestamp.
      * 
-     * @todo enforce historical query by making sure timestamps conform (we do
-     *       not want to allow read/write tx queries unless update semantics are
-     *       introduced ala SPARQL 1.1).
-     * 
-     * @todo Use a distributed read-only tx for queries (it would be nice if a
-     *       tx used 2PL to specify which namespaces it could touch).
+     *         FIXME GROUP_COMMIT: Review all callers. They are suspect. The
+     *         code will sometimes resolve the KB as of the timestamp, but,
+     *         given that the default is to read against the lastCommitTime,
+     *         that does NOT prevent a concurrent destroy or create of a KB that
+     *         invalidates such a pre-condition test. The main reason for such
+     *         pre-condition tests is to provide nice HTTP status code responses
+     *         when an identified namespace does (or does not) exist. The better
+     *         way to handle this is by pushing the pre-condition test down into
+     *         the {@link RestApiTask} and then throwning out an appropriate
+     *         marked exception that gets correctly converted into an HTTP
+     *         BAD_REQUEST message rather than sending back a stack trace.
      */
     public AbstractTripleStore getTripleStore(final String namespace,
             final long timestamp) {
@@ -2214,8 +2260,12 @@
      * @throws SailException
      * 
      * @throws RepositoryException
+     * 
+     *             FIXME GROUP COMMIT: This is deprecated by the support for
+     *             {@link RestApiMutationTask}s
      */
-    public BigdataSailRepositoryConnection getUnisolatedConnection( // FIXME REVIEW CALLERS
+    @Deprecated // deprecated by the 
+    BigdataSailRepositoryConnection getUnisolatedConnection(
             final String namespace) throws SailException, RepositoryException {
 
         // resolve the default namespace.

Modified: branches/BIGDATA_RELEASE_1_3_0/bigdata-sails/src/java/com/bigdata/rdf/sail/webapp/BigdataRDFServlet.java
===================================================================
--- branches/BIGDATA_RELEASE_1_3_0/bigdata-sails/src/java/com/bigdata/rdf/sail/webapp/BigdataRDFServlet.java	2014-06-17 20:51:10 UTC (rev 8500)
+++ branches/BIGDATA_RELEASE_1_3_0/bigdata-sails/src/java/com/bigdata/rdf/sail/webapp/BigdataRDFServlet.java	2014-06-17 21:14:25 UTC (rev 8501)
@@ -47,8 +47,6 @@
 import org.openrdf.model.Resource;
 import org.openrdf.model.Statement;
 import org.openrdf.model.impl.URIImpl;
-import org.openrdf.repository.RepositoryException;
-import org.openrdf.repository.RepositoryResult;
 import org.openrdf.rio.RDFFormat;
 import org.openrdf.rio.RDFHandlerException;
 import org.openrdf.rio.RDFWriter;
@@ -59,7 +57,6 @@
 import com.bigdata.rdf.properties.PropertiesWriter;
 import com.bigdata.rdf.properties.PropertiesWriterRegistry;
 import com.bigdata.rdf.rules.ConstraintViolationException;
-import com.bigdata.rdf.sail.webapp.XMLBuilder.Node;
 import com.bigdata.util.InnerCause;
 
 /**
@@ -398,41 +395,7 @@
         buildResponse(resp, HTTP_OK, MIME_APPLICATION_XML, w.toString());
 
     }
-    
-    /**
-     * Report the contexts back to the user agent.
-     * 
-     * @param resp
-     *            The response.
-     * @param it
-     *            The iteration of contexts.
-     * @param elapsed
-     *            The elapsed time (milliseconds).
-     * 
-     * @throws IOException
-     */
-    static protected void reportContexts(final HttpServletResponse resp,
-            final RepositoryResult<Resource> contexts, final long elapsed)
-            throws IOException, RepositoryException {
-
-        final StringWriter w = new StringWriter();
         
-        final XMLBuilder t = new XMLBuilder(w);
-
-        final Node root = t.root("contexts");
-
-        while (contexts.hasNext()) {
-
-            root.node("context").attr("uri", contexts.next()).close();
-
-        }
-
-        root.close();
-
-        buildResponse(resp, HTTP_OK, MIME_APPLICATION_XML, w.toString());
-
-    }
-    
     /**
      * Send an RDF Graph as a response using content negotiation.
      * 

Modified: branches/BIGDATA_RELEASE_1_3_0/bigdata-sails/src/java/com/bigdata/rdf/sail/webapp/BigdataServlet.java
===================================================================
--- branches/BIGDATA_RELEASE_1_3_0/bigdata-sails/src/java/com/bigdata/rdf/sail/webapp/BigdataServlet.java	2014-06-17 20:51:10 UTC (rev 8500)
+++ branches/BIGDATA_RELEASE_1_3_0/bigdata-sails/src/java/com/bigdata/rdf/sail/webapp/BigdataServlet.java	2014-06-17 21:14:25 UTC (rev 8501)
@@ -34,6 +34,7 @@
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.Future;
+import java.util.concurrent.FutureTask;
 
 import javax.servlet.ServletContext;
 import javax.servlet.http.HttpServlet;
@@ -53,6 +54,7 @@
 import com.bigdata.rdf.sail.webapp.client.IMimeTypes;
 import com.bigdata.rdf.sail.webapp.lbs.IHALoadBalancerPolicy;
 import com.bigdata.rdf.store.AbstractTripleStore;
+import com.bigdata.resources.IndexManager;
 import com.bigdata.service.IBigdataFederation;
 
 /**
@@ -216,22 +218,49 @@
      * @see <a href="- http://sourceforge.net/apps/trac/bigdata/ticket/566" >
      *      Concurrent unisolated operations against multiple KBs </a>
      */
-    @SuppressWarnings({ "unchecked", "rawtypes" })
     protected <T> Future<T> submitApiTask(final RestApiTask<T> task)
             throws DatasetNotFoundException {
 
+        final IIndexManager indexManager = getIndexManager();
+
+        return submitApiTask(indexManager, task);
+        
+    }
+    
+    /**
+     * Submit a task and return a {@link Future} for that task. The task will be
+     * run on the appropriate executor service depending on the nature of the
+     * backing database and the view required by the task.
+     * 
+     * @param indexManager
+     *            The {@link IndexManager}.
+     * @param task
+     *            The task.
+     * 
+     * @return The {@link Future} for that task.
+     * 
+     * @throws DatasetNotFoundException
+     * 
+     * @see <a href="http://sourceforge.net/apps/trac/bigdata/ticket/753" > HA
+     *      doLocalAbort() should interrupt NSS requests and AbstractTasks </a>
+     * @see <a href="- http://sourceforge.net/apps/trac/bigdata/ticket/566" >
+     *      Concurrent unisolated operations against multiple KBs </a>
+     */
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    static protected <T> Future<T> submitApiTask(
+            final IIndexManager indexManager, final RestApiTask<T> task)
+            throws DatasetNotFoundException {
+
         final String namespace = task.getNamespace();
         
         final long timestamp = task.getTimestamp();
         
-        final IIndexManager indexManager = getIndexManager();
-
         if (!BigdataStatics.NSS_GROUP_COMMIT || indexManager instanceof IBigdataFederation
                 || TimestampUtility.isReadOnly(timestamp)
                 ) {
 
             /*
-             * Run on a normal executor service.
+             * Execute the REST API task.
              * 
              * Note: For scale-out, the operation will be applied using
              * client-side global views of the indices.
@@ -240,10 +269,31 @@
              * a Journal). This is helpful since we can avoid some overhead
              * associated the AbstractTask lock declarations.
              */
-
-            return indexManager.getExecutorService().submit(
+            // Wrap Callable.
+            final FutureTask<T> ft = new FutureTask<T>(
                     new RestApiTaskForIndexManager(indexManager, task));
 
+            if (true) {
+
+                /*
+                 * Caller runs (synchronous execution)
+                 * 
+                 * Note: By having the caller run the task here we avoid
+                 * consuming another thread.
+                 */
+                ft.run();
+                
+            } else {
+                
+                /*
+                 * Run on a normal executor service.
+                 */
+                indexManager.getExecutorService().submit(ft);
+                
+            }
+
+            return ft;
+
         } else {
 
             /**
@@ -282,7 +332,7 @@
         }
 
     }
-
+    
     /**
      * Acquire the locks for the named indices associated with the specified KB.
      * 

Modified: branches/BIGDATA_RELEASE_1_3_0/bigdata-sails/src/java/com/bigdata/rdf/sail/webapp/BlueprintsServlet.java
===================================================================
--- branches/BIGDATA_RELEASE_1_3_0/bigdata-sails/src/java/com/bigdata/rdf/sail/webapp/BlueprintsServlet.java	2014-06-17 20:51:10 UTC (rev 8500)
+++ branches/BIGDATA_RELEASE_1_3_0/bigdata-sails/src/java/com/bigdata/rdf/sail/webapp/BlueprintsServlet.java	2014-06-17 21:14:25 UTC (rev 8501)
@@ -33,8 +33,8 @@
 
 import com.bigdata.blueprints.BigdataGraphBulkLoad;
 import com.bigdata.rdf.sail.BigdataSailRepositoryConnection;
+import com.bigdata.rdf.sail.webapp.RestApiTask.RestApiMutationTask;
 import com.bigdata.rdf.sail.webapp.client.MiniMime;
-import com.bigdata.rdf.store.AbstractTripleStore;
 import com.tinkerpop.blueprints.util.io.graphml.GraphMLReader;
 
 /**
@@ -69,16 +69,8 @@
     protected void doPost(final HttpServletRequest req,
             final HttpServletResponse resp) throws IOException {
 
-        final long begin = System.currentTimeMillis();
-        
-        final String namespace = getNamespace(req);
-
-        final long timestamp = getTimestamp(req);
-
-        final AbstractTripleStore tripleStore = getBigdataRDFContext()
-                .getTripleStore(namespace, timestamp);
-        
-        if (tripleStore == null) {
+        if (getBigdataRDFContext().getTripleStore(getNamespace(req),
+                getTimestamp(req)) == null) {
             /*
              * There is no such triple/quad store instance.
              */
@@ -104,12 +96,37 @@
         
         try {
             
+            submitApiTask(
+                    new BlueprintsPostTask(req, resp, getNamespace(req),
+                            getTimestamp(req))).get();
+
+        } catch (Throwable t) {
+
+            throw BigdataRDFServlet.launderThrowable(t, resp, "");
+            
+        }
+        
+    }
+
+    private static class BlueprintsPostTask extends RestApiMutationTask<Void> {
+
+        public BlueprintsPostTask(HttpServletRequest req,
+                HttpServletResponse resp, String namespace, long timestamp) {
+
+            super(req, resp, namespace, timestamp);
+
+        }
+
+        @Override
+        public Void call() throws Exception {
+
+            final long begin = System.currentTimeMillis();
+            
             BigdataSailRepositoryConnection conn = null;
             boolean success = false;
             try {
 
-                conn = getBigdataRDFContext()
-                        .getUnisolatedConnection(namespace);
+                conn = getUnisolatedConnection();
                 
                 final BigdataGraphBulkLoad graph = new BigdataGraphBulkLoad(conn);
 
@@ -123,10 +140,11 @@
 
                 final long elapsed = System.currentTimeMillis() - begin;
                 
-                reportModifiedCount(resp, nmodified, elapsed);
-                
-                return;
+                reportModifiedCount(nmodified, elapsed);
 
+                // Done.
+                return null;
+
             } finally {
 
                 if (conn != null) {
@@ -137,15 +155,11 @@
       ...
 
[truncated message content]

Thread: [Bigdata-commit] SF.net SVN: bigdata:[8501] branches/BIGDATA_RELEASE_1_3_0 (Page 6)

Fast, scalable, robust graph database platform

bigdata-commit