jena-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From rve...@apache.org
Subject [44/68] [abbrv] [partial] reverting accidentally deleted files
Date Wed, 22 Oct 2014 11:39:59 GMT
http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/FusekiConfig.java
----------------------------------------------------------------------
diff --git a/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/FusekiConfig.java b/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/FusekiConfig.java
new file mode 100644
index 0000000..9c36a7c
--- /dev/null
+++ b/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/FusekiConfig.java
@@ -0,0 +1,374 @@
+/*
+ * 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.jena.fuseki.server;
+
+import java.lang.reflect.Method ;
+import java.util.ArrayList ;
+import java.util.Arrays ;
+import java.util.List ;
+
+import org.apache.jena.atlas.iterator.Iter ;
+import org.apache.jena.atlas.lib.StrUtils ;
+import org.apache.jena.fuseki.Fuseki ;
+import org.apache.jena.fuseki.FusekiConfigException ;
+import org.apache.jena.fuseki.HttpNames ;
+import org.slf4j.Logger ;
+
+import com.hp.hpl.jena.assembler.Assembler ;
+import com.hp.hpl.jena.assembler.JA ;
+import com.hp.hpl.jena.query.ARQ ;
+import com.hp.hpl.jena.query.Dataset ;
+import com.hp.hpl.jena.query.Query ;
+import com.hp.hpl.jena.query.QueryExecution ;
+import com.hp.hpl.jena.query.QueryExecutionFactory ;
+import com.hp.hpl.jena.query.QueryFactory ;
+import com.hp.hpl.jena.query.QuerySolution ;
+import com.hp.hpl.jena.query.QuerySolutionMap ;
+import com.hp.hpl.jena.query.ResultSet ;
+import com.hp.hpl.jena.query.ResultSetFactory ;
+import com.hp.hpl.jena.rdf.model.Literal ;
+import com.hp.hpl.jena.rdf.model.Model ;
+import com.hp.hpl.jena.rdf.model.RDFNode ;
+import com.hp.hpl.jena.rdf.model.ResIterator ;
+import com.hp.hpl.jena.rdf.model.Resource ;
+import com.hp.hpl.jena.rdf.model.Statement ;
+import com.hp.hpl.jena.rdf.model.StmtIterator ;
+import com.hp.hpl.jena.shared.PrefixMapping ;
+import com.hp.hpl.jena.sparql.core.DatasetGraph ;
+import com.hp.hpl.jena.sparql.core.DatasetGraphFactory ;
+import com.hp.hpl.jena.sparql.core.DatasetGraphReadOnly ;
+import com.hp.hpl.jena.sparql.core.assembler.AssemblerUtils ;
+import com.hp.hpl.jena.tdb.TDB ;
+import com.hp.hpl.jena.util.FileManager ;
+import com.hp.hpl.jena.vocabulary.RDF ;
+import com.hp.hpl.jena.vocabulary.RDFS ;
+
+public class FusekiConfig
+{
+    static { Fuseki.init(); }
+
+    // The datastructure that captures a servers configuration.
+    
+    // Server port
+    int port ;
+    // Management command port - -1 for none.
+    int mgtPort ;           
+    List<DatasetRef> datasets = null ;
+    
+    
+    private static Logger log = Fuseki.configLog ;
+    
+    private static String prefixes = StrUtils.strjoinNL(
+    "PREFIX fu:     <http://jena.apache.org/fuseki#>" ,
+    "PREFIX rdf:    <http://www.w3.org/1999/02/22-rdf-syntax-ns#>",
+    "PREFIX rdfs:   <http://www.w3.org/2000/01/rdf-schema#>",
+    "PREFIX tdb:    <http://jena.hpl.hp.com/2008/tdb#>",
+    "PREFIX list:   <http://jena.hpl.hp.com/ARQ/list#>",
+    "PREFIX list:   <http://jena.hpl.hp.com/ARQ/list#>",
+    "PREFIX xsd:     <http://www.w3.org/2001/XMLSchema#>",
+    "PREFIX apf:     <http://jena.hpl.hp.com/ARQ/property#>", 
+    "PREFIX afn:     <http://jena.hpl.hp.com/ARQ/function#>" ,
+    "") ;
+    
+    public static ServerConfig defaultConfiguration(String datasetPath, DatasetGraph dsg, boolean allowUpdate, boolean listenLocal)
+    {
+        DatasetRef dbDesc = new DatasetRef() ;
+        dbDesc.name = datasetPath ;
+        dbDesc.dataset = dsg ;
+        dbDesc.query.endpoints.add(HttpNames.ServiceQuery) ;
+        dbDesc.query.endpoints.add(HttpNames.ServiceQueryAlt) ;
+
+        if ( allowUpdate )
+        {
+            dbDesc.update.endpoints.add(HttpNames.ServiceUpdate) ;
+            dbDesc.upload.endpoints.add(HttpNames.ServiceUpload) ;
+            dbDesc.readWriteGraphStore.endpoints.add(HttpNames.ServiceData) ;
+            dbDesc.allowDatasetUpdate = true ;
+        }
+        else
+            dbDesc.readGraphStore.endpoints.add(HttpNames.ServiceData) ;
+        ServerConfig config = new ServerConfig() ;
+        config.datasets = Arrays.asList(dbDesc) ;
+        config.port = 3030 ;
+        config.mgtPort = 3031 ;
+        config.pagesPort = config.port ;
+        config.loopback = listenLocal ;
+        config.jettyConfigFile = null ;
+        config.pages = Fuseki.PagesStatic ;
+        config.enableCompression = true ;
+        config.verboseLogging = false ;
+        return config ;
+    }
+    
+    public static ServerConfig configure(String filename)
+    {
+        // Be absolutely sure everything has initialized.
+        // Some initialization registers assemblers and sets abbreviation vocabulary. 
+        ARQ.init();
+        TDB.init() ;
+        Fuseki.init() ;
+        Model m = FileManager.get().loadModel(filename) ;
+
+        // Find one server.
+        List<Resource> servers = getByType(FusekiVocab.tServer, m) ;
+        if ( servers.size() == 0 )
+            throw new FusekiConfigException("No server found (no resource with type "+strForResource(FusekiVocab.tServer)) ;
+        if ( servers.size() > 1 )
+            throw new FusekiConfigException(servers.size()+" servers found (must be exactly one in a configuration file)") ;
+        
+        // ---- Server 
+        Resource server = servers.get(0) ;
+        processServer(server) ;
+
+        // ---- Services
+        ResultSet rs = query("SELECT * { ?s fu:services [ list:member ?member ] }", m) ; 
+        if ( ! rs.hasNext() )
+            log.warn("No services found") ;
+        
+        List<DatasetRef> services =  new ArrayList<DatasetRef>() ; 
+        
+        for ( ; rs.hasNext() ; )
+        {
+            QuerySolution soln = rs.next() ;
+            Resource svc = soln.getResource("member") ;
+            DatasetRef sd = processService(svc) ;
+            services.add(sd) ;
+        }
+        
+        // TODO Properties for the other fields.
+        ServerConfig config = new ServerConfig() ;
+        config.datasets = services ;
+        config.port = 3030 ;
+        config.mgtPort = 3031 ;
+        config.pagesPort = config.port ;
+        config.jettyConfigFile = null ;
+        config.pages = Fuseki.PagesStatic ;
+        config.enableCompression = true ;
+        config.verboseLogging = false ;
+        return config ;
+    }
+    
+
+    // DatasetRef used where there isn't a real Dataset e.g. the SPARQL processor.  
+    
+    private static DatasetRef noDataset      = new DatasetRef() ;
+    private static DatasetGraph dummyDSG        = new DatasetGraphReadOnly(DatasetGraphFactory.createMemFixed()) ;
+    static {
+        noDataset.name = "" ;
+        noDataset.dataset = dummyDSG ;
+        noDataset.query.endpoints.add(HttpNames.ServiceQuery) ;
+        noDataset.query.endpoints.add(HttpNames.ServiceQueryAlt) ;
+        noDataset.allowDatasetUpdate = false ;
+        noDataset.init();
+        // Don't register it.  
+        // This is used as a placeholder and shoudl not be found by "all datasets"  
+        // DatasetRegistry.get().put("", noDataset) ;
+    }
+
+    /** Return the DatasetRef (read-only) for when there is no dataset, just a SPARQL Query processor */ 
+    public static DatasetRef serviceOnlyDatasetRef() { return noDataset ; }
+
+    private static void processServer(Resource server)
+    {
+        // Global, currently.
+        AssemblerUtils.setContext(server, Fuseki.getContext()) ;
+        
+        StmtIterator sIter = server.listProperties(JA.loadClass) ;
+        for( ; sIter.hasNext(); )
+        {
+            Statement s = sIter.nextStatement() ;
+            RDFNode rn = s.getObject() ;
+            String className = null ;
+            if ( rn instanceof Resource )
+            {
+                String uri = ((Resource)rn).getURI() ;
+                if ( uri == null )
+                {
+                    log.warn("Blank node for class to load") ;
+                    continue ;
+                }
+                String javaScheme = "java:" ;
+                if ( ! uri.startsWith(javaScheme) )
+                {
+                    log.warn("Class to load is not 'java:': "+uri) ;
+                    continue ;
+                }
+                className = uri.substring(javaScheme.length()) ;
+            }
+            if ( rn instanceof Literal )
+                className = ((Literal)rn).getLexicalForm() ; 
+            /*Loader.*/loadAndInit(className) ;
+        }
+        // ----
+    }
+
+    private static void loadAndInit(String className)
+    {
+        try {
+            Class<?> classObj = Class.forName(className);
+            log.info("Loaded "+className) ;
+            Method initMethod = classObj.getMethod("init");
+            initMethod.invoke(null);
+        } catch (ClassNotFoundException ex)
+        {
+            log.warn("Class not found: "+className);
+        } 
+        catch (Exception e)         { throw new FusekiConfigException(e) ; }
+    }
+
+    private static DatasetRef processService(Resource svc)
+    {
+        log.info("Service: "+nodeLabel(svc)) ;
+        DatasetRef sDesc = new DatasetRef() ;
+        sDesc.name = ((Literal)getOne(svc, "fu:name")).getLexicalForm() ;
+        log.info("  name = "+sDesc.name) ;
+
+        addServiceEP("query", sDesc.name, sDesc.query, svc, "fu:serviceQuery") ; 
+        addServiceEP("update", sDesc.name, sDesc.update, svc, "fu:serviceUpdate") ; 
+        addServiceEP("upload", sDesc.name, sDesc.upload, svc, "fu:serviceUpload") ;
+        addServiceEP("graphStore(RW)", sDesc.name, sDesc.readWriteGraphStore, svc, "fu:serviceReadWriteGraphStore") ;
+        addServiceEP("graphStore(R)", sDesc.name, sDesc.readGraphStore, svc, "fu:serviceReadGraphStore") ;
+        // Extract timeout overriding configuration if present.
+        if (svc.hasProperty(FusekiVocab.pAllowTimeoutOverride)) {
+            sDesc.allowTimeoutOverride = svc.getProperty(FusekiVocab.pAllowTimeoutOverride).getObject().asLiteral().getBoolean();
+            if (svc.hasProperty(FusekiVocab.pMaximumTimeoutOverride)) {
+                sDesc.maximumTimeoutOverride = (int) (svc.getProperty(FusekiVocab.pMaximumTimeoutOverride).getObject().asLiteral().getFloat() * 1000);
+            }
+        }
+        
+        Resource datasetDesc = ((Resource)getOne(svc, "fu:dataset")) ;
+
+        // Check if it is in the model.
+        if ( ! datasetDesc.hasProperty(RDF.type) )
+            throw new FusekiConfigException("No rdf:type for dataset "+nodeLabel(datasetDesc)) ;
+        
+        Dataset ds = (Dataset)Assembler.general.open(datasetDesc)  ;
+        sDesc.dataset = ds.asDatasetGraph() ; 
+        return sDesc ;
+        
+    }
+    
+    private static RDFNode getOne(Resource svc, String property)
+    {
+        String ln = property.substring(property.indexOf(':')+1) ;
+        ResultSet rs = query("SELECT * { ?svc "+property+" ?x}", svc.getModel(), "svc", svc) ;
+        if ( ! rs.hasNext() )
+            throw new FusekiConfigException("No "+ln+" for service "+nodeLabel(svc)) ;
+        RDFNode x = rs.next().get("x") ;
+        if ( rs.hasNext() )
+            throw new FusekiConfigException("Multiple "+ln+" for service "+nodeLabel(svc)) ;
+        return x ;
+    }
+    
+    private static List<Resource> getByType(Resource type, Model m)
+    {
+        ResIterator rIter = m.listSubjectsWithProperty(RDF.type, type) ;
+        return Iter.toList(rIter) ;
+    }
+
+    private static void addServiceEP(String label, String name, ServiceRef service, Resource svc, String property)
+    {
+        ResultSet rs = query("SELECT * { ?svc "+property+" ?ep}", svc.getModel(), "svc", svc) ;
+        for ( ; rs.hasNext() ; )
+        {
+            QuerySolution soln = rs.next() ;
+            String epName = soln.getLiteral("ep").getLexicalForm() ;
+            service.endpoints.add(epName) ;
+            log.info("  "+label+" = /"+name+"/"+epName) ;
+        }
+    }
+
+
+    private static ResultSet query(String string, Model m)
+    {
+        return query(string, m, null, null) ;
+    }
+
+    private static ResultSet query(String string, Model m, String varName, RDFNode value)
+    {
+        Query query = QueryFactory.create(prefixes+string) ;
+        QuerySolutionMap initValues = null ;
+        if ( varName != null )
+            initValues = querySolution(varName, value) ;
+        try(QueryExecution qExec = QueryExecutionFactory.create(query, m, initValues)) {
+            ResultSet rs = ResultSetFactory.copyResults(qExec.execSelect()) ;
+            return rs ;
+        }
+    }
+    
+    private static QuerySolutionMap querySolution(String varName, RDFNode value)
+    {
+        QuerySolutionMap qsm = new QuerySolutionMap() ;
+        querySolution(qsm, varName, value) ;
+        return qsm ;
+    }
+    
+    private static QuerySolutionMap querySolution(QuerySolutionMap qsm, String varName, RDFNode value)
+    {
+        qsm.add(varName, value) ;
+        return qsm ;
+    }
+    
+    // Node presentation
+    private static String nodeLabel(RDFNode n)
+    {
+        if ( n == null )
+            return "<null>" ;
+        if ( n instanceof Resource )
+            return strForResource((Resource)n) ;
+        
+        Literal lit = (Literal)n ;
+        return lit.getLexicalForm() ;
+    }
+    
+    private static String strForResource(Resource r) { return strForResource(r, r.getModel()) ; }
+    
+    private static String strForResource(Resource r, PrefixMapping pm)
+    {
+        if ( r == null )
+            return "NULL ";
+        if ( r.hasProperty(RDFS.label))
+        {
+            RDFNode n = r.getProperty(RDFS.label).getObject() ;
+            if ( n instanceof Literal )
+                return ((Literal)n).getString() ;
+        }
+        
+        if ( r.isAnon() )
+            return "<<blank node>>" ;
+
+        if ( pm == null )
+            pm = r.getModel() ;
+
+        return strForURI(r.getURI(), pm ) ;
+    }
+    
+    private static String strForURI(String uri, PrefixMapping pm)
+    {
+        if ( pm != null )
+        {
+            String x = pm.shortForm(uri) ;
+            
+            if ( ! x.equals(uri) )
+                return x ;
+        }
+        return "<"+uri+">" ;
+    }
+}
+

http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/FusekiErrorHandler.java
----------------------------------------------------------------------
diff --git a/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/FusekiErrorHandler.java b/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/FusekiErrorHandler.java
new file mode 100644
index 0000000..d1660f5
--- /dev/null
+++ b/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/FusekiErrorHandler.java
@@ -0,0 +1,92 @@
+/*
+ * 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.jena.fuseki.server;
+
+import static java.lang.String.format ;
+
+import java.io.* ;
+
+import javax.servlet.http.HttpServletRequest ;
+import javax.servlet.http.HttpServletResponse ;
+
+import org.apache.jena.fuseki.Fuseki ;
+import org.apache.jena.web.HttpSC ;
+import org.eclipse.jetty.http.HttpHeaders ;
+import org.eclipse.jetty.http.HttpMethods ;
+import org.eclipse.jetty.http.MimeTypes ;
+import org.eclipse.jetty.server.AbstractHttpConnection ;
+import org.eclipse.jetty.server.Request ;
+import org.eclipse.jetty.server.handler.ErrorHandler ;
+
+public class FusekiErrorHandler extends ErrorHandler
+{
+    @Override
+    public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException
+    {
+        AbstractHttpConnection connection = AbstractHttpConnection.getCurrentConnection();
+        connection.getRequest().setHandled(true);
+        String method = request.getMethod();
+     
+        if(!method.equals(HttpMethods.GET) && !method.equals(HttpMethods.POST) && !method.equals(HttpMethods.HEAD))
+            return;
+        
+        response.setContentType(MimeTypes.TEXT_PLAIN_UTF_8) ;
+        response.setHeader(HttpHeaders.CACHE_CONTROL, "must-revalidate,no-cache,no-store") ;
+        
+        ByteArrayOutputStream bytes = new ByteArrayOutputStream(1024) ;
+        //String writer = IO.UTF8(null) ;
+        try(Writer writer = new OutputStreamWriter(bytes, "UTF-8")) {
+
+            handleErrorPage(request, writer, connection.getResponse().getStatus(), connection.getResponse().getReason());
+
+            if ( ! Fuseki.VERSION.equalsIgnoreCase("development") )
+            {
+                writer.write("\n") ;
+                writer.write("\n") ;
+                writer.write(format("Fuseki - version %s (Build date: %s)\n", Fuseki.VERSION, Fuseki.BUILD_DATE)) ;
+            }
+            writer.flush();
+        }
+        response.setContentLength(bytes.size()) ;
+        // Copy
+        response.getOutputStream().write(bytes.toByteArray()) ;
+    }
+    
+    @Override
+    protected void handleErrorPage(HttpServletRequest request, Writer writer, int code, String message)
+        throws IOException
+    {
+        if ( message == null )
+            message = HttpSC.getMessage(code) ;
+        writer.write(format("Error %d: %s\n", code, message)) ;
+        
+        Throwable th = (Throwable)request.getAttribute("javax.servlet.error.exception");
+        while(th!=null)
+        {
+            writer.write("\n");
+            StringWriter sw = new StringWriter();
+            PrintWriter pw = new PrintWriter(sw);
+            th.printStackTrace(pw);
+            pw.flush();
+            writer.write(sw.getBuffer().toString());
+            writer.write("\n");
+            th = th.getCause();
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/FusekiServletContextListener.java
----------------------------------------------------------------------
diff --git a/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/FusekiServletContextListener.java b/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/FusekiServletContextListener.java
new file mode 100644
index 0000000..f1c9642
--- /dev/null
+++ b/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/FusekiServletContextListener.java
@@ -0,0 +1,43 @@
+/**
+ * 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.jena.fuseki.server;
+
+import javax.servlet.ServletContextEvent ;
+import javax.servlet.ServletContextListener ;
+
+public class FusekiServletContextListener implements ServletContextListener {
+    // This could do the initialization. 
+    private final SPARQLServer sparqlServer ;
+    public FusekiServletContextListener(SPARQLServer sparqlServer) {
+        this.sparqlServer = sparqlServer ;
+    }
+
+    @Override
+    public void contextInitialized(ServletContextEvent sce) {
+//        Fuseki.serverLog.info("contextInitialized") ;
+//        for ( DatasetRef dsRef : sparqlServer.getDatasets() )
+//            Fuseki.serverLog.info("Dataset: "+dsRef.getName()) ;
+    }
+
+    @Override
+    public void contextDestroyed(ServletContextEvent sce) {
+//        Fuseki.serverLog.info("contextDestroyed") ;
+    }
+}
+

http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/FusekiVocab.java
----------------------------------------------------------------------
diff --git a/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/FusekiVocab.java b/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/FusekiVocab.java
new file mode 100644
index 0000000..d4d4e54
--- /dev/null
+++ b/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/FusekiVocab.java
@@ -0,0 +1,62 @@
+/*
+ * 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.jena.fuseki.server;
+
+import org.apache.jena.fuseki.FusekiException ;
+import org.apache.jena.iri.IRI ;
+import org.apache.jena.riot.system.IRIResolver ;
+
+import com.hp.hpl.jena.rdf.model.Property ;
+import com.hp.hpl.jena.rdf.model.Resource ;
+import com.hp.hpl.jena.rdf.model.ResourceFactory ;
+
+public class FusekiVocab
+{
+    public static String NS = "http://jena.apache.org/fuseki#" ;
+
+    public static final Resource tServer = resource("Server") ;
+
+    public static final Property pServices = property("services") ;
+    public static final Property pServiceName = property("name") ;
+    
+    public static final Property pServiceQueryEP = property("serviceQuery") ;
+    public static final Property pServiceUpdateEP = property("serviceUpdate") ;
+    public static final Property pServiceUploadEP = property("serviceUpload") ;
+    public static final Property pServiceReadWriteGraphStoreEP = property("serviceReadWriteGraphStore") ;
+    public static final Property pServiceReadgraphStoreEP = property("serviceReadGraphStore") ;
+
+    public static final Property pAllowTimeoutOverride = property("allowTimeoutOverride");
+    public static final Property pMaximumTimeoutOverride = property("maximumTimeoutOverride");
+
+    private static Resource resource(String localname) { return ResourceFactory.createResource(iri(localname)) ; }
+    private static Property property(String localname) { return ResourceFactory.createProperty(iri(localname)) ; }
+        
+    private static String iri(String localname)
+    {
+        String uri = NS+localname ;
+        IRI iri = IRIResolver.parseIRI(uri) ;
+        if ( iri.hasViolation(true) )
+            throw new FusekiException("Bad IRI: "+iri) ;
+        if ( ! iri.isAbsolute() )
+            throw new FusekiException("Bad IRI: "+iri) ;
+        
+        return uri ;
+    }
+}
+

http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/SPARQLServer.java
----------------------------------------------------------------------
diff --git a/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/SPARQLServer.java b/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/SPARQLServer.java
new file mode 100644
index 0000000..7448eb2
--- /dev/null
+++ b/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/SPARQLServer.java
@@ -0,0 +1,484 @@
+/*
+ * 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.jena.fuseki.server ;
+
+import static java.lang.String.format ;
+import static org.apache.jena.fuseki.Fuseki.serverLog ;
+
+import java.io.FileInputStream ;
+import java.util.* ;
+
+import javax.servlet.DispatcherType ;
+import javax.servlet.http.HttpServlet ;
+
+import org.apache.jena.atlas.lib.FileOps ;
+import org.apache.jena.fuseki.Fuseki ;
+import org.apache.jena.fuseki.FusekiException ;
+import org.apache.jena.fuseki.HttpNames ;
+import org.apache.jena.fuseki.mgt.ActionDataset ;
+import org.apache.jena.fuseki.mgt.MgtFunctions ;
+import org.apache.jena.fuseki.mgt.PageNames ;
+import org.apache.jena.fuseki.servlets.* ;
+import org.apache.jena.fuseki.validation.DataValidator ;
+import org.apache.jena.fuseki.validation.IRIValidator ;
+import org.apache.jena.fuseki.validation.QueryValidator ;
+import org.apache.jena.fuseki.validation.UpdateValidator ;
+import org.apache.jena.riot.WebContent ;
+import org.eclipse.jetty.http.MimeTypes ;
+import org.eclipse.jetty.security.* ;
+import org.eclipse.jetty.security.authentication.BasicAuthenticator ;
+import org.eclipse.jetty.server.Connector ;
+import org.eclipse.jetty.server.Server ;
+import org.eclipse.jetty.server.nio.BlockingChannelConnector ;
+import org.eclipse.jetty.servlet.DefaultServlet ;
+import org.eclipse.jetty.servlet.ServletContextHandler ;
+import org.eclipse.jetty.servlet.ServletHolder ;
+import org.eclipse.jetty.servlets.GzipFilter ;
+import org.eclipse.jetty.util.security.Constraint ;
+import org.eclipse.jetty.xml.XmlConfiguration ;
+
+import com.hp.hpl.jena.sparql.mgt.ARQMgt ;
+import com.hp.hpl.jena.sparql.util.Utils ;
+
+/**
+ * SPARQLServer is the Jena server instance which wraps/utilizes 
+ * {@link org.eclipse.jetty.server.Server}. This class provides
+ * immediate access to the {@link org.eclipse.jetty.server.Server#start()} and 
+ * {@link org.eclipse.jetty.server.Server#stop()} commands as well as obtaining
+ * instances of the server and server configuration. Finally we can obtain 
+ * instances of {@link org.apache.jena.fuseki.server.ServerConfig}.
+ *
+ */
+public class SPARQLServer {
+    static {
+        Fuseki.init() ;
+    }
+
+    private ServerConfig        serverConfig ;
+
+    private Server              server         = null ;
+    private static List<String> epDataset      = Arrays.asList("*") ;
+
+    /**
+     * Default constructor which requires a {@link org.apache.jena.fuseki.server.ServerConfig}
+     * object as input. We use this config to specify (verbose) logging, enable compression
+     * etc. 
+     * @param config
+     */
+    public SPARQLServer(ServerConfig config) {
+        this.serverConfig = config ;
+        // Currently server-wide.
+        Fuseki.verboseLogging = config.verboseLogging ;
+
+        // GZip compression
+        // Note that regardless of this setting we'll always leave it turned off
+        // for the servlets
+        // where it makes no sense to have it turned on e.g. update and upload
+
+        ServletContextHandler context = buildServer(serverConfig.jettyConfigFile, config.enableCompression) ;
+        configureDatasets(context) ;
+    }
+
+    private void configureDatasets(ServletContextHandler context) {
+        // Build them all.
+        for (DatasetRef dsDesc : serverConfig.datasets)
+            configureOneDataset(context, dsDesc, serverConfig.enableCompression) ;
+        
+    }
+    
+    /**
+     * Initialize the {@link SPARQLServer} instance.
+     */
+    public void start() {
+        String now = Utils.nowAsString() ;
+        serverLog.info(format("%s %s %s", Fuseki.NAME, Fuseki.VERSION, Fuseki.BUILD_DATE)) ;
+        // This does not get set usefully for Jetty as we use it.
+        // String jettyVersion = org.eclipse.jetty.server.Server.getVersion() ;
+        // serverLog.info(format("Jetty %s",jettyVersion)) ;
+        String host = server.getConnectors()[0].getHost() ;
+        if ( host != null )
+            serverLog.info("Incoming connections limited to " + host) ;
+        serverLog.info(format("Started %s on port %d", now, server.getConnectors()[0].getPort())) ;
+
+        try {
+            server.start() ;
+        } catch (java.net.BindException ex) {
+            serverLog.error("SPARQLServer: Failed to start server: " + ex.getMessage()) ;
+            System.exit(1) ;
+        } catch (Exception ex) {
+            serverLog.error("SPARQLServer: Failed to start server: " + ex.getMessage(), ex) ;
+            System.exit(1) ;
+        }
+
+        ServletContextHandler context = (ServletContextHandler)server.getHandler() ;
+    }
+
+    /**
+     * Stop the {@link SPARQLServer} instance.
+     */
+    public void stop() {
+        String now = Utils.nowAsString() ;
+        serverLog.info(format("Stopped %s on port %d", now, server.getConnectors()[0].getPort())) ;
+        try {
+            server.stop() ;
+        } catch (Exception ex) {
+            Fuseki.serverLog.warn("SPARQLServer: Exception while stopping server: " + ex.getMessage(), ex) ;
+        }
+        removeJMX() ;
+    }
+
+    /**
+     * Get the Jetty instance.
+     * @return Server
+     */
+    public Server getServer() {
+        return server ;
+    }
+
+    /**
+     * Get the datasets associated with the server.
+     * @return returns the datasets via {@link org.apache.jena.fuseki.server.ServerConfig#datasets}
+     */
+    public List<DatasetRef> getDatasets() {
+        return serverConfig.datasets ;
+    }
+
+    /**
+     * Obtain the {@link org.apache.jena.fuseki.server.ServerConfig}
+     * @return ServerConfig
+     */
+    public ServerConfig getServerConfig() {
+        return serverConfig ;
+    }
+
+    // Later : private and in constructor.
+    private ServletContextHandler buildServer(String jettyConfig, boolean enableCompression) {
+        if ( jettyConfig != null ) {
+            // --jetty-config=jetty-fuseki.xml
+            // for detailed configuration of the server using Jetty features.
+            server = configServer(jettyConfig) ;
+        } else
+            server = defaultServerConfig(serverConfig.port, serverConfig.loopback) ;
+        // Keep the server to a maximum number of threads.
+        // server.setThreadPool(new QueuedThreadPool(ThreadPoolSize)) ;
+
+        ServletContextHandler context = new ServletContextHandler(ServletContextHandler.SESSIONS) ;
+        context.setErrorHandler(new FusekiErrorHandler()) ;
+        context.addEventListener(new FusekiServletContextListener(this));
+        
+        // Increase form size.
+        context.getServletContext().getContextHandler().setMaxFormContentSize(10 * 1000 * 1000) ;
+
+        // Wire up authentication if appropriate
+        if ( jettyConfig == null && serverConfig.authConfigFile != null ) {
+            Constraint constraint = new Constraint() ;
+            constraint.setName(Constraint.__BASIC_AUTH) ;
+            constraint.setRoles(new String[]{"fuseki"}) ;
+            constraint.setAuthenticate(true) ;
+
+            ConstraintMapping mapping = new ConstraintMapping() ;
+            mapping.setConstraint(constraint) ;
+            mapping.setPathSpec("/*") ;
+
+            IdentityService identService = new DefaultIdentityService() ;
+
+            ConstraintSecurityHandler securityHandler = new ConstraintSecurityHandler() ;
+            securityHandler.addConstraintMapping(mapping) ;
+            securityHandler.setIdentityService(identService) ;
+
+            HashLoginService loginService = new HashLoginService("Fuseki Authentication", serverConfig.authConfigFile) ;
+            loginService.setIdentityService(identService) ;
+
+            securityHandler.setLoginService(loginService) ;
+            securityHandler.setAuthenticator(new BasicAuthenticator()) ;
+
+            context.setSecurityHandler(securityHandler) ;
+
+            serverLog.debug("Basic Auth Configuration = " + serverConfig.authConfigFile) ;
+        }
+
+        // Wire up context handler to server
+        server.setHandler(context) ;
+
+        // Constants. Add RDF types.
+        MimeTypes mt = new MimeTypes() ;
+        mt.addMimeMapping("rdf", WebContent.contentTypeRDFXML + ";charset=utf-8") ;
+        mt.addMimeMapping("ttl", WebContent.contentTypeTurtle + ";charset=utf-8") ;
+        mt.addMimeMapping("nt", WebContent.contentTypeNTriples + ";charset=ascii") ;
+        mt.addMimeMapping("nq", WebContent.contentTypeNQuads + ";charset=ascii") ;
+        mt.addMimeMapping("trig", WebContent.contentTypeTriG + ";charset=utf-8") ;
+
+        // mt.addMimeMapping("tpl", "text/html;charset=utf-8") ;
+        context.setMimeTypes(mt) ;
+        server.setHandler(context) ;
+
+        serverLog.debug("Pages = " + serverConfig.pages) ;
+
+        boolean installManager = true ;
+        boolean installServices = true ;
+
+        String validationRoot = "/validate" ;
+
+        // Should all services be /_/.... or some such?
+
+        if ( installManager || installServices ) {
+            // TODO Respect port.
+            if ( serverConfig.pagesPort != serverConfig.port )
+                serverLog.warn("Not supported yet - pages on a different port to services") ;
+             if ( serverConfig.pages != null ) {
+                 if ( ! FileOps.exists(serverConfig.pages) )
+                     serverLog.warn("No pages directory - "+serverConfig.pages) ;
+                String base = serverConfig.pages ;
+                Map<String, Object> data = new HashMap<String, Object>() ;
+                data.put("mgt", new MgtFunctions()) ;
+                SimpleVelocityServlet templateEngine = new SimpleVelocityServlet(base, data) ;
+                addServlet(context, templateEngine, "*.tpl", false) ;
+             }
+        }
+
+        if ( installManager ) {
+            // Action when control panel selects a dataset.
+            HttpServlet datasetChooser = new ActionDataset() ;
+            addServlet(context, datasetChooser, PageNames.actionDatasetNames, false) ;
+        }
+
+        if ( installServices ) {
+            // Validators
+            HttpServlet validateQuery = new QueryValidator() ;
+            HttpServlet validateUpdate = new UpdateValidator() ;
+            HttpServlet validateData = new DataValidator() ;
+            HttpServlet validateIRI = new IRIValidator() ;
+
+            HttpServlet dumpService = new DumpServlet() ;
+            HttpServlet generalQueryService = new SPARQL_QueryGeneral() ;
+
+            addServlet(context, validateQuery, validationRoot + "/query", false) ;
+            addServlet(context, validateUpdate, validationRoot + "/update", false) ;
+            addServlet(context, validateData, validationRoot + "/data", false) ;
+            addServlet(context, validateIRI, validationRoot + "/iri", false) ;
+
+            // general query processor.
+            addServlet(context, generalQueryService, HttpNames.ServiceGeneralQuery, enableCompression) ;
+        }
+
+        if ( installManager || installServices ) {
+            String[] files = {"fuseki.html", "index.html"} ;
+            context.setWelcomeFiles(files) ;
+            addContent(context, "/", serverConfig.pages) ;
+        }
+
+        return context ;
+    }
+
+    /** Experimental - off by default. The überservlet sits on the dataset name and handles all requests.
+      * Includes direct naming and quad access to the dataset. 
+      */
+    public static boolean       überServlet       = false ;
+    
+    private static List<String> ListOfEmptyString = Arrays.asList("") ;
+
+    private void configureOneDataset(ServletContextHandler context, DatasetRef dsDesc, boolean enableCompression) {
+        String datasetPath = dsDesc.name ;
+        if ( datasetPath.equals("/") )
+            datasetPath = "" ;
+        else
+            if ( !datasetPath.startsWith("/") )
+                datasetPath = "/" + datasetPath ;
+
+        if ( datasetPath.endsWith("/") )
+            datasetPath = datasetPath.substring(0, datasetPath.length() - 1) ;
+
+        dsDesc.init() ;
+
+        DatasetRegistry.get().put(datasetPath, dsDesc) ;
+        serverLog.info(format("Dataset path = %s", datasetPath)) ;
+
+        HttpServlet sparqlQuery = new SPARQL_QueryDataset() ;
+        HttpServlet sparqlUpdate = new SPARQL_Update() ;
+        HttpServlet sparqlUpload = new SPARQL_Upload() ;
+        HttpServlet sparqlHttpR = new SPARQL_REST_R() ;
+        HttpServlet sparqlHttpRW = new SPARQL_REST_RW() ;
+        HttpServlet sparqlDataset = new SPARQL_UberServlet.AccessByConfig() ;
+
+        if ( !überServlet ) {
+            // If uberserver, these are unnecessary but can be used.
+            // If just means the überservlet isn't handling these operations.
+            addServlet(context, datasetPath, sparqlQuery, dsDesc.query, enableCompression) ;
+            addServlet(context, datasetPath, sparqlUpdate, dsDesc.update, false) ;
+            addServlet(context, datasetPath, sparqlUpload, dsDesc.upload, false) ; // No point - no results of any size.
+            addServlet(context, datasetPath, sparqlHttpR, dsDesc.readGraphStore, enableCompression) ;
+            addServlet(context, datasetPath, sparqlHttpRW, dsDesc.readWriteGraphStore, enableCompression) ;
+            // This adds direct operations on the dataset itself.
+            // addServlet(context, datasetPath, sparqlDataset,
+            // ListOfEmptyString, enableCompression) ;
+        } else {
+            // This is the servlet that analyses requests and dispatches them to
+            // the appropriate servlet.
+            // SPARQL Query, SPARQL Update -- handles dataset?query=
+            // dataset?update=
+            // Graph Store Protocol (direct and indirect naming) if enabled.
+            // GET/PUT/POST on the dataset itself.
+            // It also checks for a request that looks like a service request
+            // and passes it
+            // on to the service (this takes precedence over direct naming).
+            addServlet(context, datasetPath, sparqlDataset, epDataset, enableCompression) ;
+        }
+
+        // Add JMX beans to record daatset and it's services.
+        addJMX(dsDesc) ;
+    }
+
+    private static Server configServer(String jettyConfig) {
+        try {
+            serverLog.info("Jetty server config file = " + jettyConfig) ;
+            Server server = new Server() ;
+            XmlConfiguration configuration = new XmlConfiguration(new FileInputStream(jettyConfig)) ;
+            configuration.configure(server) ;
+            return server ;
+        } catch (Exception ex) {
+            serverLog.error("SPARQLServer: Failed to configure server: " + ex.getMessage(), ex) ;
+            throw new FusekiException("Failed to configure a server using configuration file '" + jettyConfig + "'") ;
+        }
+    }
+
+    private static Server defaultServerConfig(int port, boolean loopback) {
+        // Server, with one NIO-based connector, large input buffer size (for
+        // long URLs, POSTed forms (queries, updates)).
+        Server server = new Server() ;
+
+        // Using "= new SelectChannelConnector() ;" on Darwin (OS/X) causes
+        // problems
+        // with initialization not seen (thread scheduling?) in Joseki.
+
+        // BlockingChannelConnector is better for pumping large responses back
+        // but there have been observed problems with DirectMemory allocation
+        // (-XX:MaxDirectMemorySize=1G does not help)
+        // Connector connector = new SelectChannelConnector() ;
+
+        // Connector and specific settings.
+        BlockingChannelConnector bcConnector = new BlockingChannelConnector() ;
+        // bcConnector.setUseDirectBuffers(false) ;
+
+        Connector connector = bcConnector ;
+        // Ignore. If set, then if this goes off, it keeps going off
+        // and you get a lot of log messages.
+        connector.setMaxIdleTime(0) ; // Jetty outputs a lot of messages if this
+                                      // goes off.
+        if ( loopback )
+            connector.setHost("localhost");
+        connector.setPort(port) ;
+        // Some people do try very large operations ...
+        connector.setRequestHeaderSize(64 * 1024) ;
+        connector.setRequestBufferSize(5 * 1024 * 1024) ;
+        connector.setResponseBufferSize(5 * 1024 * 1024) ;
+        server.addConnector(connector) ;
+        return server ;
+    }
+
+    private static void addContent(ServletContextHandler context, String pathSpec, String pages) {
+        DefaultServlet staticServlet = new DefaultServlet() ;
+        ServletHolder staticContent = new ServletHolder(staticServlet) ;
+        staticContent.setInitParameter("resourceBase", pages) ;
+
+        // Note we set GZip to false for static content because the Jetty
+        // DefaultServlet has
+        // a built-in GZip capability that is better for static content than the
+        // mechanism the
+        // GzipFilter uses for dynamic content
+        addServlet(context, staticContent, pathSpec, false) ;
+    }
+
+    private void addServlet(ServletContextHandler context, String datasetPath, HttpServlet servlet,
+                            ServiceRef serviceRef, boolean enableCompression) {
+        addServlet(context, datasetPath, servlet, serviceRef.endpoints, enableCompression) ;
+    }
+
+    // SHARE
+    private static void addServlet(ServletContextHandler context, String datasetPath, HttpServlet servlet,
+                                   List<String> pathSpecs, boolean enableCompression) {
+        for (String pathSpec : pathSpecs) {
+            if ( pathSpec.equals("") ) {
+                // "" is special -- add as "base" and "base/"
+                addServlet(context, servlet, datasetPath + "/", enableCompression) ;
+                addServlet(context, servlet, datasetPath, enableCompression) ;
+                continue ;
+            }
+
+            if ( pathSpec.endsWith("/") )
+                pathSpec = pathSpec.substring(0, pathSpec.length() - 1) ;
+            if ( pathSpec.startsWith("/") )
+                pathSpec = pathSpec.substring(1, pathSpec.length()) ;
+            addServlet(context, servlet, datasetPath + "/" + pathSpec, enableCompression) ;
+        }
+    }
+
+    private static void addServlet(ServletContextHandler context, HttpServlet servlet, String pathSpec,
+                                   boolean enableCompression) {
+        ServletHolder holder = new ServletHolder(servlet) ;
+        addServlet(context, holder, pathSpec, enableCompression) ;
+    }
+
+    private static void addServlet(ServletContextHandler context, ServletHolder holder, String pathSpec,
+                                   boolean enableCompression) {
+        if ( serverLog.isDebugEnabled() ) {
+            if ( enableCompression )
+                serverLog.debug("Add servlet @ " + pathSpec + " (with gzip)") ;
+            else
+                serverLog.debug("Add servlet @ " + pathSpec) ;
+        }
+        context.addServlet(holder, pathSpec) ;
+
+        if ( enableCompression )
+            context.addFilter(GzipFilter.class, pathSpec, EnumSet.allOf(DispatcherType.class)) ;
+    }
+
+    private void addJMX() {
+        DatasetRegistry registry = DatasetRegistry.get() ;
+        for (String ds : registry.keys()) {
+            DatasetRef dsRef = registry.get(ds) ;
+            addJMX(dsRef) ;
+        }
+    }
+
+    private void addJMX(DatasetRef dsRef) {
+        String x = dsRef.name ;
+        // if ( x.startsWith("/") )
+        // x = x.substring(1) ;
+        ARQMgt.register(Fuseki.PATH + ".dataset:name=" + x, dsRef) ;
+        // For all endpoints
+        for (ServiceRef sRef : dsRef.getServiceRefs()) {
+            ARQMgt.register(Fuseki.PATH + ".dataset:name=" + x + "/" + sRef.name, sRef) ;
+        }
+    }
+
+    private void removeJMX() {
+        DatasetRegistry registry = DatasetRegistry.get() ;
+        for (String ds : registry.keys()) {
+            DatasetRef ref = registry.get(ds) ;
+        }
+    }
+
+    private void removeJMX(DatasetRef dsRef) {
+        String x = dsRef.getName() ;
+        ARQMgt.unregister(Fuseki.PATH + ".dataset:name=" + x) ;
+        for (ServiceRef sRef : dsRef.getServiceRefs()) {
+            ARQMgt.unregister(Fuseki.PATH + ".dataset:name=" + x + "/" + sRef.name) ;
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/ServerConfig.java
----------------------------------------------------------------------
diff --git a/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/ServerConfig.java b/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/ServerConfig.java
new file mode 100644
index 0000000..4e0b865
--- /dev/null
+++ b/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/ServerConfig.java
@@ -0,0 +1,55 @@
+/**
+ * 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.jena.fuseki.server;
+
+import java.util.List ;
+
+/** This represents a configuration of a SPARQL server.
+ */
+
+public class ServerConfig
+{
+    public ServerConfig() {}
+    
+    /** Port to run the server service on */
+    public int port ;
+    /** Port for the management interface : -1 for no management interface */ 
+    public int mgtPort ;
+    /** Port for the pages UI : this can be the same as the services port. */ 
+    public int pagesPort ;
+    /** Jetty config file - if null, use the built-in configuration of Jetty */
+    public String jettyConfigFile = null ;
+    /** Listen only on the loopback (localhost) interface */
+    public boolean loopback = false ;
+    /** The local directory for serving the static pages */ 
+    public String pages ;
+    /** The list of datasets */
+    public List<DatasetRef> datasets ;
+    /** Enable Accept-Encoding compression. Set to false by default.*/
+    public boolean enableCompression = false ;
+    
+    /** Enable additional logging */
+    public boolean verboseLogging = false ;
+    /**
+     * Authentication config file used to setup Jetty Basic auth, if a Jetty config file was set this is ignored since Jetty config allows much more complex auth methods to be implemented
+     */
+    public String authConfigFile ;
+
+}
+

http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/ServiceMXBean.java
----------------------------------------------------------------------
diff --git a/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/ServiceMXBean.java b/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/ServiceMXBean.java
new file mode 100644
index 0000000..11c7330
--- /dev/null
+++ b/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/ServiceMXBean.java
@@ -0,0 +1,32 @@
+/**
+ * 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.jena.fuseki.server;
+
+public interface ServiceMXBean
+{
+    String getName() ;
+    
+    long getRequests() ;
+    long getRequestsGood() ;
+    long getRequestsBad() ;
+    
+//    void enable() ;
+//    void disable() ;
+}
+

http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/ServiceRef.java
----------------------------------------------------------------------
diff --git a/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/ServiceRef.java b/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/ServiceRef.java
new file mode 100644
index 0000000..6236050
--- /dev/null
+++ b/jena-fuseki/src/main/java/org/apache/jena/fuseki/server/ServiceRef.java
@@ -0,0 +1,63 @@
+/**
+ * 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.jena.fuseki.server;
+
+import java.util.ArrayList ;
+import java.util.List ;
+
+/** Configuration of an individual service */
+public class ServiceRef implements ServiceMXBean, Counters
+{
+    public final String name ;
+    
+    // Service-level counters.
+    private final CounterSet counters           = new CounterSet() ;
+    @Override
+    public  CounterSet getCounters() { return counters ; }
+
+    /** Endpoints (as absolute path URLs) */
+    public List<String> endpoints               = new ArrayList<String>() ;
+    
+    // Attach counters to services or datasets 
+    // Can we have a counter of the same name on different services?
+    // Cost : number of maps.
+    // +ve: Multiple services with the same name counter
+    
+    public ServiceRef(String serviceName) {
+        this.name = serviceName ;
+    }
+    
+    public boolean isActive() { return endpoints.isEmpty() ; }
+
+    @Override
+    public String getName()     { return name ; }
+
+    @Override public long getRequests() { 
+        return counters.value(CounterName.Requests) ;
+    }
+    @Override
+    public long getRequestsGood() {
+        return counters.value(CounterName.RequestsGood) ;
+    }
+    @Override
+    public long getRequestsBad() {
+        return counters.value(CounterName.RequestsBad) ;
+    }
+}
+

http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki/src/main/java/org/apache/jena/fuseki/servlets/ActionErrorException.java
----------------------------------------------------------------------
diff --git a/jena-fuseki/src/main/java/org/apache/jena/fuseki/servlets/ActionErrorException.java b/jena-fuseki/src/main/java/org/apache/jena/fuseki/servlets/ActionErrorException.java
new file mode 100644
index 0000000..6c5ebe9
--- /dev/null
+++ b/jena-fuseki/src/main/java/org/apache/jena/fuseki/servlets/ActionErrorException.java
@@ -0,0 +1,32 @@
+/*
+ * 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.jena.fuseki.servlets;
+
+class ActionErrorException extends RuntimeException
+{
+    final Throwable exception ;
+    final String message ;
+    final int rc ;
+    ActionErrorException(Throwable ex, String message, int rc)
+    {
+        this.exception = ex ;
+        this.message = message ;
+        this.rc = rc ;
+    }
+}

http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki/src/main/java/org/apache/jena/fuseki/servlets/ConcurrencyPolicyMRSW.java
----------------------------------------------------------------------
diff --git a/jena-fuseki/src/main/java/org/apache/jena/fuseki/servlets/ConcurrencyPolicyMRSW.java b/jena-fuseki/src/main/java/org/apache/jena/fuseki/servlets/ConcurrencyPolicyMRSW.java
new file mode 100644
index 0000000..259453d
--- /dev/null
+++ b/jena-fuseki/src/main/java/org/apache/jena/fuseki/servlets/ConcurrencyPolicyMRSW.java
@@ -0,0 +1,113 @@
+/*
+ * 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.jena.fuseki.servlets;
+
+import java.util.ConcurrentModificationException ;
+import java.util.concurrent.atomic.AtomicLong ;
+
+import org.apache.jena.fuseki.Fuseki ;
+import org.slf4j.Logger ;
+
+public final class ConcurrencyPolicyMRSW
+{
+    static private Logger log = Fuseki.requestLog ; //org.slf4j.LoggerFactory.getLogger(ConcurrencyPolicyMRSW.class) ;
+    static private final boolean logging = false ; //log.isDebugEnabled() ;
+    
+    // This is a simplified version of ConcurrencyPolicyMRSW from TDB. 
+    private final AtomicLong readCounter = new AtomicLong(0) ;
+    private final AtomicLong writeCounter = new AtomicLong(0) ;
+    static private final AtomicLong policyCounter = new AtomicLong(0) ;
+
+    public ConcurrencyPolicyMRSW()
+    { policyCounter.incrementAndGet() ; }
+
+    // Loggin -inside the operation.
+    
+    //@Override
+    public void startRead()
+    {
+        readCounter.getAndIncrement() ;
+        log() ;
+        checkConcurrency() ;
+    }
+
+    //@Override
+    public void finishRead()
+    {
+        log() ;
+        readCounter.decrementAndGet() ;
+        checkConcurrency() ;
+    }
+
+    //@Override
+    public void startUpdate()
+    {
+        writeCounter.getAndIncrement() ;
+        log() ;
+        checkConcurrency() ;
+    }
+
+    //@Override
+    public void finishUpdate()
+    {
+        log() ;
+        writeCounter.decrementAndGet() ;
+        checkConcurrency() ;
+    }
+
+    private synchronized void checkConcurrency()
+    {
+        long R = readCounter.get() ;
+        long W = writeCounter.get() ;
+        long id = policyCounter.get();
+        if ( R > 0 && W > 0 )
+            policyError(id, R, W) ;
+        if ( W > 1 )
+            policyError(id, R, W) ;
+    }
+
+    private void log()
+    {
+        if ( ! logging ) 
+            return ;
+        long R , W , id ;
+        synchronized(this)
+        {
+            R = readCounter.get() ;
+            W = writeCounter.get() ;
+            id = policyCounter.get();
+        }
+        log.info(format(id, R, W)) ;
+    }
+    
+    private static void policyError(long id, long R, long W)
+    {
+        policyError(format(id, R, W)) ;
+    }
+
+    private static void policyError(String message)
+    {
+        throw new ConcurrentModificationException(message) ;
+    }
+    
+    private static String format(long id, long R, long W)
+    {
+        return String.format("(lock=%d) Reader = %d, Writer = %d", id, R, W) ;
+    }
+}

http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki/src/main/java/org/apache/jena/fuseki/servlets/DumpServlet.java
----------------------------------------------------------------------
diff --git a/jena-fuseki/src/main/java/org/apache/jena/fuseki/servlets/DumpServlet.java b/jena-fuseki/src/main/java/org/apache/jena/fuseki/servlets/DumpServlet.java
new file mode 100644
index 0000000..7ece249
--- /dev/null
+++ b/jena-fuseki/src/main/java/org/apache/jena/fuseki/servlets/DumpServlet.java
@@ -0,0 +1,313 @@
+/*
+ * 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.
+ */
+
+/** A servlet that dumps its request
+ */
+
+// Could be neater - much, much neater!
+package org.apache.jena.fuseki.servlets;
+
+import java.io.BufferedReader ;
+import java.io.IOException ;
+import java.io.PrintWriter ;
+import java.io.StringWriter ;
+import java.util.Date ;
+import java.util.Enumeration ;
+import java.util.Locale ;
+import java.util.Properties ;
+
+import javax.servlet.ServletContext ;
+import javax.servlet.http.Cookie ;
+import javax.servlet.http.HttpServlet ;
+import javax.servlet.http.HttpServletRequest ;
+import javax.servlet.http.HttpServletResponse ;
+
+public class DumpServlet extends HttpServlet
+{
+    private static final long serialVersionUID = 99L;  // Serilizable.
+
+
+    public DumpServlet()
+    {
+
+    }
+
+    @Override
+    public void init()
+    {
+        return ;
+    }
+
+    @Override
+    public void doGet(HttpServletRequest req, HttpServletResponse resp)
+    {
+        try {
+            PrintWriter out = resp.getWriter() ;
+            resp.setContentType("text/html");
+
+            String now = new Date().toString() ;
+
+            // HEAD
+            out.println("<html>") ;
+            out.println("<head>") ;
+            out.println("<Title>Dump @ "+now+"</Title>") ;
+            // Reduce the desire to cache it.
+            out.println("<meta CONTENT=now HTTP-EQUIV=expires>") ;
+            out.println("</head>") ;
+
+            // BODY
+            out.println("<body>") ;
+            out.println("<pre>") ;
+
+            out.println("Dump : "+now);
+            out.println() ;
+            out.println("==== Request");
+            out.println() ;
+            out.print(dumpRequest(req)) ;
+            out.println() ;
+                        
+            out.println(">>>> Body");
+            out.println() ;
+            printBody(out, req) ;
+            out.println("<<<< Body");
+            
+            out.println("==== ServletContext");
+            out.println() ;
+            out.print(dumpServletContext());
+            out.println() ;
+
+            out.println("==== Environment");
+            out.println() ;
+            out.print(dumpEnvironment());
+            out.println() ;
+
+            out.println("</pre>") ;
+
+            out.println("</body>") ;
+            out.println("</html>") ;
+            out.flush() ;
+        } catch (IOException e)
+        { }
+    }
+
+    // This resets the input stream
+
+    static public String dumpRequest(HttpServletRequest req)
+    { 
+         StringWriter sw = new StringWriter() ;
+         try( PrintWriter pw = new PrintWriter(sw) ) {
+            // Standard environment
+            pw.println("Method:                 "+req.getMethod());
+            pw.println("getContentLength:       "+Integer.toString(req.getContentLength()));
+            pw.println("getContentType:         "+req.getContentType());
+            pw.println("getRequestURI:          "+req.getRequestURI());
+            pw.println("getRequestURL:          "+req.getRequestURL());
+            pw.println("getContextPath:         "+req.getContextPath());
+            pw.println("getServletPath:         "+req.getServletPath());
+            pw.println("getPathInfo:            "+req.getPathInfo());
+            pw.println("getPathTranslated:      "+req.getPathTranslated());
+            pw.println("getQueryString:         "+req.getQueryString());
+            pw.println("getProtocol:            "+req.getProtocol());
+            pw.println("getScheme:              "+req.getScheme());
+            pw.println("getServerName:          "+req.getServerName());
+            pw.println("getServerPort:          "+req.getServerPort());
+            pw.println("getRemoteUser:          "+req.getRemoteUser());
+            pw.println("getRemoteAddr:          "+req.getRemoteAddr());
+            pw.println("getRemoteHost:          "+req.getRemoteHost());
+            pw.println("getRequestedSessionId:  "+req.getRequestedSessionId());
+            {
+                Cookie c[] = req.getCookies() ;
+                if ( c == null )
+                    pw.println("getCookies:            <none>");
+                else
+                {
+                    for ( Cookie aC : c )
+                    {
+                        pw.println( "Cookie:        " + aC.getName() );
+                        pw.println( "    value:     " + aC.getValue() );
+                        pw.println( "    version:   " + aC.getVersion() );
+                        pw.println( "    comment:   " + aC.getComment() );
+                        pw.println( "    domain:    " + aC.getDomain() );
+                        pw.println( "    maxAge:    " + aC.getMaxAge() );
+                        pw.println( "    path:      " + aC.getPath() );
+                        pw.println( "    secure:    " + aC.getSecure() );
+                        pw.println();
+                    }
+                }
+            }
+            
+            {
+                // To do: create a string for the output so can send to console and return it.
+                Enumeration<String> en = req.getHeaderNames() ;
+
+                for ( ; en.hasMoreElements() ; )
+                {
+                    String name = en.nextElement() ;
+                    String value = req.getHeader(name) ;
+                    pw.println("Head: "+name + " = " + value) ;
+                }
+            }
+            
+            Enumeration<String> en2 = req.getAttributeNames() ;
+            if ( en2.hasMoreElements() )
+                pw.println();
+            for ( ; en2.hasMoreElements() ; )
+            {
+                String name = en2.nextElement() ;
+                String value = req.getAttribute(name).toString() ;
+                pw.println("Attr: "+name + " = " + value) ;
+            }
+
+            // Note that doing this on a form causes the forms content (body) to be read
+            // and parsed as form variables.
+//            en = req.getParameterNames() ;
+//            if ( en.hasMoreElements() )
+//                pw.println();
+//            for ( ; en.hasMoreElements() ; )
+//            {
+//                String name = (String)en.nextElement() ;
+//                String value = req.getParameter(name) ;
+//                pw.println("Param: "+name + " = " + value) ;
+//            }
+
+
+            
+//            MultiMap<String, String> map = WebLib.parseQueryString(req) ;
+//            for ( String name : map.keys() )
+//                for ( String value : map.get(name) )
+//                    pw.println("Param: "+name + " = " + value) ;
+            
+            Enumeration<Locale> en = req.getLocales() ;
+            if ( en.hasMoreElements() )
+                pw.println();
+            for ( ; en.hasMoreElements() ; )
+            {
+                String name = en.nextElement().toString() ;
+                pw.println("Locale: "+name) ;
+            }
+
+            pw.println() ;
+            pw.flush();
+            //printBody(pw, req) ;
+            return sw.toString() ;
+        }
+         
+    }
+
+    static void printBody(PrintWriter pw, HttpServletRequest req) throws IOException
+    {
+        BufferedReader in = req.getReader() ;
+        if ( req.getContentLength() > 0 )
+            // Need +2 because last line may not have a CR/LF on it.
+            in.mark(req.getContentLength()+2) ;
+        else
+            // This is a dump - try to do something that works, even if inefficient.
+            in.mark(100*1024) ;
+
+        while(true)
+        {
+            String x = in.readLine() ;
+            if ( x == null )
+                break ;
+            x = x.replaceAll("&", "&amp;") ;
+            x = x.replaceAll("<", "&lt;") ;
+            x = x.replaceAll(">", "&gt;") ;
+            pw.println(x) ;
+        }
+        try { in.reset() ;} catch (IOException e) { System.out.println("DumpServlet: Reset of content failed: "+e) ; }
+    }
+    
+    /**
+     * <code>dumpEnvironment</code>
+     * @return String that is the HTML of the System properties as name/value pairs.
+     * The values are with single quotes independent of whether or not the value has
+     * single quotes in it.
+     */
+    static public String dumpEnvironment()
+    {
+        Properties properties = System.getProperties();
+
+        StringWriter sw = new StringWriter() ;
+        try(PrintWriter pw = new PrintWriter(sw) ) {
+            Enumeration<Object> en = properties.keys();
+            while(en.hasMoreElements())
+            {
+                String key = en.nextElement().toString();
+                pw.println(key+": '"+properties.getProperty(key)+"'");
+            }
+            pw.println() ;
+            pw.flush() ;
+            return sw.toString() ; 
+        }
+    }
+
+    public String dumpServletContext()
+    {
+        StringWriter sw = new StringWriter() ;
+        try(PrintWriter pw = new PrintWriter(sw)) {
+
+            ServletContext sc =  getServletContext();
+            pw.println("majorVersion: '"+sc.getMajorVersion()+"'");
+            pw.println("minorVersion: '"+sc.getMinorVersion()+"'");
+            pw.println("contextName:  '"+sc.getServletContextName()+"'");
+            pw.println("servletInfo:  '"+getServletInfo()+"'");
+            pw.println("serverInfo:  '"+sc.getServerInfo()+"'");
+
+            {
+                Enumeration<String> en = sc.getInitParameterNames();
+                if (en != null) {
+                    pw.println("initParameters: ");
+                    while(en.hasMoreElements())
+                    {
+                        String key = en.nextElement();
+                        pw.println(key+": '"+sc.getInitParameter(key)+"'");
+                    }
+                }
+            }
+
+            {
+                Enumeration<String> en = sc.getAttributeNames();
+                if (en != null) {
+                    pw.println("attributes: ");
+                    while(en.hasMoreElements())
+                    {
+                        String key = en.nextElement();
+                        pw.println(key+": '"+sc.getAttribute(key)+"'");
+                    }
+                }
+            }
+            pw.println() ;
+            pw.close() ;
+        }
+        return sw.toString() ;      
+    }
+
+    
+    @Override
+    public void doPost(HttpServletRequest req, HttpServletResponse resp)
+    {
+        doGet(req, resp) ;
+    }
+
+
+    @Override
+    public String getServletInfo()
+    {
+        return "Dump";
+    }
+}

http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki/src/main/java/org/apache/jena/fuseki/servlets/HttpAction.java
----------------------------------------------------------------------
diff --git a/jena-fuseki/src/main/java/org/apache/jena/fuseki/servlets/HttpAction.java b/jena-fuseki/src/main/java/org/apache/jena/fuseki/servlets/HttpAction.java
new file mode 100644
index 0000000..39663dd
--- /dev/null
+++ b/jena-fuseki/src/main/java/org/apache/jena/fuseki/servlets/HttpAction.java
@@ -0,0 +1,290 @@
+/*
+ * 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.jena.fuseki.servlets;
+
+import static com.hp.hpl.jena.query.ReadWrite.READ ;
+import static com.hp.hpl.jena.query.ReadWrite.WRITE ;
+
+import java.util.HashMap ;
+import java.util.Map ;
+
+import javax.servlet.http.HttpServletRequest ;
+import javax.servlet.http.HttpServletResponse ;
+
+import org.apache.jena.atlas.logging.Log ;
+import org.apache.jena.atlas.web.MediaType ;
+import org.apache.jena.fuseki.DEF ;
+import org.apache.jena.fuseki.conneg.ConNeg ;
+import org.apache.jena.fuseki.server.DatasetRef ;
+import org.apache.jena.fuseki.server.ServiceRef ;
+
+import com.hp.hpl.jena.query.ReadWrite ;
+import com.hp.hpl.jena.sparql.SystemARQ ;
+import com.hp.hpl.jena.sparql.core.DatasetGraph ;
+import com.hp.hpl.jena.sparql.core.DatasetGraphWithLock ;
+import com.hp.hpl.jena.sparql.core.DatasetGraphWrapper ;
+import com.hp.hpl.jena.sparql.core.Transactional ;
+
+/**
+ * HTTP action that represents the user request lifecycle. Its state is handled in the
+ * {@link SPARQL_ServletBase#executeLifecycle(HttpAction)} method.
+ */
+public class HttpAction
+{
+    public final long id ;
+    public final boolean verbose ;
+    
+    // Phase two items - set and valida after the datasetRef is known.  
+    private DatasetGraph dsg ;                  // The data
+    public DatasetRef dsRef ;
+    public ServiceRef srvRef ;
+    
+    private Transactional transactional ;
+    private boolean isTransactional;
+    private DatasetGraph    activeDSG ;             // Set when inside begin/end.
+    private ReadWrite       activeMode ;            // Set when inside begin/end.
+    
+    private boolean startTimeIsSet = false ;
+    private boolean finishTimeIsSet = false ;
+
+    private long startTime = -2 ;
+    private long finishTime = -2 ;
+    
+    // Incoming
+    //public final 
+    
+    // Outcome.
+    int statusCode = -1 ;
+    String message = null ;
+    int contentLength = -1 ;
+    String contentType = null ;
+    
+    // Cleared to archive:
+    Map <String, String> headers = new HashMap<String, String>() ;
+    public HttpServletRequest request;
+    public HttpServletResponseTracker response ;
+
+    /**
+     * Creates a new HTTP Action, using the HTTP request and response, and a given ID.
+     *
+     * @param id given ID
+     * @param request HTTP request
+     * @param response HTTP response
+     * @param verbose verbose flag
+     */
+    public HttpAction(long id, HttpServletRequest request, HttpServletResponse response, boolean verbose) {
+        this.id = id ;
+        this.request = request ;
+        this.response = new HttpServletResponseTracker(this, response) ;
+        // Should this be set when setDataset is called from the dataset context?
+        // Currently server-wide, e.g. from the command line.
+        this.verbose = verbose ;
+    }
+
+    /**
+     * <p>Sets the action dataset. Setting a {@link DatasetRef} will replace any existing DatasetRef, as well as
+     * as the {@link DatasetGraph} of the current HTTP Action.</p>
+     *
+     * <p>Once it has updated its members, the HTTP Action will change its transactional state and
+     * {@link Transactional} instance according to its base dataset graph.</p>
+     *
+     * @param desc {@link DatasetRef}
+     * @see Transactional
+     * @see DatasetGraphWrapper
+     */
+    public void setDataset(DatasetRef desc) {
+        this.dsRef = desc ;
+        this.dsg = desc.dataset ;
+        DatasetGraph basedsg = unwrap(dsg) ;
+
+        if ( isTransactional(basedsg) && isTransactional(dsg) ) {
+            // Use transactional if it looks safe - abort is necessary.
+            transactional = (Transactional)dsg ;
+            isTransactional = true ;
+        } else {
+            // Unsure if safe
+            transactional = new DatasetGraphWithLock(dsg) ;
+            // No real abort.
+            isTransactional = false ;
+        }
+    }
+
+    /**
+     * Returns <code>true</code> iff the given {@link DatasetGraph} is an instance of {@link Transactional},
+     * <code>false otherwise</code>.
+     *
+     * @param dsg a {@link DatasetGraph}
+     * @return <code>true</code> iff the given {@link DatasetGraph} is an instance of {@link Transactional},
+     * <code>false otherwise</code>
+     */
+    private static boolean isTransactional(DatasetGraph dsg) {
+        return (dsg instanceof Transactional) ;
+    }
+
+    /**
+     * A {@link DatasetGraph} may contain other <strong>wrapped DatasetGraph's</strong>. This method will return
+     * the first instance (including the argument to this method) that <strong>is not</strong> an instance of
+     * {@link DatasetGraphWrapper}.
+     *
+     * @param dsg a {@link DatasetGraph}
+     * @return the first found {@link DatasetGraph} that is not an instance of {@link DatasetGraphWrapper}
+     */
+    private static DatasetGraph unwrap(DatasetGraph dsg) {
+        while (dsg instanceof DatasetGraphWrapper) {
+            dsg = ((DatasetGraphWrapper)dsg).getWrapped() ;
+        }
+        return dsg ;
+    }
+
+    /**
+     * Sets the {@link ServiceRef}.
+     *
+     * @param srvRef a {@link ServiceRef}
+     */
+    public void setService(ServiceRef srvRef) {
+        this.srvRef = srvRef ; 
+    }
+    
+    /**
+     * Returns whether or not the underlying DatasetGraph is fully transactional (supports rollback).
+     * @return <code>true</code> if the underlying DatasetGraph is fully transactional (supports rollback),
+     * <code>false</code> otherwise.
+     */
+    public boolean isTransactional() {
+        return isTransactional ;
+    }
+
+    public void beginRead() {
+        activeMode = READ ;
+        transactional.begin(READ) ;
+        activeDSG = dsg ;
+        dsRef.startTxn(READ) ;
+    }
+
+    public void endRead() {
+        dsRef.finishTxn(READ) ;
+        activeMode = null ;
+        transactional.end() ;
+        activeDSG = null ;
+    }
+
+    public void beginWrite() {
+        transactional.begin(WRITE) ;
+        activeMode = WRITE ;
+        activeDSG = dsg ;
+        dsRef.startTxn(WRITE) ;
+    }
+
+    public void commit() {
+        transactional.commit() ;
+        activeDSG = null ;
+    }
+
+    public void abort() {
+        try { transactional.abort() ; } 
+        catch (Exception ex) {
+            // Some datasets claim to be transactional but
+            // don't provide a real abort. We tried to avoid
+            // them earlier but even if they sneek through,
+            // we try to continue server operation.
+            Log.warn(this, "Exception during abort (operation attempts to continue): "+ex.getMessage()) ; 
+        }
+        activeDSG = null ;
+    }
+
+    public void endWrite() {
+        dsRef.finishTxn(WRITE) ;
+        activeMode = null ;
+
+        if ( transactional.isInTransaction() ) {
+            Log.warn(this, "Transaction still active in endWriter - no commit or abort seen (forced abort)") ;
+            try {
+                transactional.abort() ;
+            } catch (RuntimeException ex) {
+                Log.warn(this, "Exception in forced abort (trying to continue)", ex) ;
+            }
+        }
+        transactional.end() ;
+        activeDSG = null ;
+    }
+   
+    public final DatasetGraph getActiveDSG() {
+        return activeDSG ;
+    }
+
+    public final DatasetRef getDatasetRef() {
+        return dsRef ;
+    }
+
+    /** Reduce to a size that can be kept around for sometime */
+    public void minimize() {
+        this.request = null ;
+        this.response = null ;
+    }
+
+    public void setStartTime() {
+        if ( startTimeIsSet ) 
+            Log.warn(this,  "Start time reset") ;
+        startTimeIsSet = true ;
+        this.startTime = System.nanoTime() ;
+    }
+
+    public void setFinishTime() {
+        if ( finishTimeIsSet ) 
+            Log.warn(this,  "Finish time reset") ;
+        finishTimeIsSet = true ;
+        this.finishTime = System.nanoTime() ;
+    }
+
+    public HttpServletRequest getRequest()              { return request ; }
+
+    public HttpServletResponseTracker getResponse()     { return response ; }
+    
+    /** Return the recorded time taken in milliseconds. 
+     *  {@linkplain #setStartTime} and {@linkplain #setFinishTime}
+     *  must have been called.
+     */
+    public long getTime()
+    {
+        if ( ! startTimeIsSet ) 
+            Log.warn(this,  "Start time not set") ;
+        if ( ! finishTimeIsSet ) 
+            Log.warn(this,  "Finish time not set") ;
+        return (finishTime-startTime)/(1000*1000) ;
+    }
+
+    public void sync() {
+        SystemARQ.sync(dsg) ;
+    }
+
+    public static MediaType contentNegotationRDF(HttpAction action) {
+        MediaType mt = ConNeg.chooseContentType(action.request, DEF.rdfOffer, DEF.acceptRDFXML) ;
+        if ( mt == null )
+            return null ;
+        if ( mt.getContentType() != null )
+            action.response.setContentType(mt.getContentType()) ;
+        if ( mt.getCharset() != null )
+            action.response.setCharacterEncoding(mt.getCharset()) ;
+        return mt ;
+    }
+
+    public static MediaType contentNegotationQuads(HttpAction action) {
+        return ConNeg.chooseContentType(action.request, DEF.quadsOffer, DEF.acceptNQuads) ;
+    }
+}

http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki/src/main/java/org/apache/jena/fuseki/servlets/HttpServletResponseTracker.java
----------------------------------------------------------------------
diff --git a/jena-fuseki/src/main/java/org/apache/jena/fuseki/servlets/HttpServletResponseTracker.java b/jena-fuseki/src/main/java/org/apache/jena/fuseki/servlets/HttpServletResponseTracker.java
new file mode 100644
index 0000000..c39e728
--- /dev/null
+++ b/jena-fuseki/src/main/java/org/apache/jena/fuseki/servlets/HttpServletResponseTracker.java
@@ -0,0 +1,140 @@
+/*
+ * 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.jena.fuseki.servlets;
+
+import java.io.IOException ;
+
+import javax.servlet.http.HttpServletResponse ;
+import javax.servlet.http.HttpServletResponseWrapper ;
+
+import org.apache.jena.atlas.logging.Log ;
+
+/** Intercepting wrapper so we can track the response settings for logging purposes */
+
+public class HttpServletResponseTracker extends HttpServletResponseWrapper
+{
+    private final HttpAction action ;
+
+    public HttpServletResponseTracker(HttpAction action, HttpServletResponse response)
+    {
+        super(response) ;
+        this.action = action ;
+    }
+
+    @Override
+    public void sendError(int sc, String msg) throws IOException
+    {
+        action.statusCode = sc ;
+        action.message = msg ;
+        super.sendError(sc, msg) ;
+    }
+
+    @Override
+    public void sendError(int sc) throws IOException
+    {
+        action.statusCode = sc ;
+        action.message = null ;
+        super.sendError(sc) ;
+    }
+
+    @Override
+    public void setHeader(String name, String value)
+    {
+        super.setHeader(name, value) ;
+        action.headers.put(name, value) ;
+    }
+
+    @Override
+    public void addHeader(String name, String value)
+    {
+        Log.warn(this, "Unexpected addHeader - not recorded in log") ;
+        super.addHeader(name, value) ;
+    }
+    @Override
+    public void setStatus(int sc) 
+    {
+        action.statusCode = sc ;
+        action.message = null ;
+        super.setStatus(sc) ;
+    }
+
+    @Override
+    @Deprecated
+    public void setStatus(int sc, String sm)
+    {
+        action.statusCode = sc ;
+        action.message = sm ;
+        super.setStatus(sc, sm) ;
+    }
+
+    @Override
+    public void setContentLength(int len)
+    {
+        action.contentLength = len ;
+        super.setContentLength(len) ;
+    }
+
+    @Override
+    public void setContentType(String type)
+    {
+        action.contentType = type ;
+        super.setContentType(type) ;
+    }
+      
+      // From HttpServletResponse
+//      public void addCookie(Cookie cookie) {}
+//      public boolean containsHeader(String name) {}
+//      public String encodeURL(String url) { }
+//      public String encodeRedirectURL(String url) {}
+//      public String encodeUrl(String url) {}
+//      public String encodeRedirectUrl(String url) {}
+//      public void sendError(int sc, String msg) throws IOException
+//      public void sendError(int sc) throws IOException
+//      public void sendRedirect(String location) throws IOException {}
+//      public void setDateHeader(String name, long date) {}
+//      public void addDateHeader(String name, long date) {}
+//      public void setHeader(String name, String value)
+//      public void addHeader(String name, String value)
+//      public void setIntHeader(String name, int value) {}
+//      public void addIntHeader(String name, int value) {}
+//      public void setStatus(int sc) 
+//      public void setStatus(int sc, String sm)
+//      public void sendRedirect(String location) throws IOException {}
+//      public void setDateHeader(String name, long date) {}
+//      public void addDateHeader(String name, long date) {}
+        
+        // From ServletResponse.
+//         public ServletResponse getResponse() {}
+//         public void setResponse(ServletResponse response) {}
+//         public void setCharacterEncoding(String charset) {}
+//         public String getCharacterEncoding() {}
+//         public ServletOutputStream getOutputStream() throws IOException {}
+//         public PrintWriter getWriter() throws IOException {}
+//         public void setContentLength(int len) {}
+//         public void setContentType(String type) {}
+//         public String getContentType() {
+//         public void setBufferSize(int size) {}
+//         public int getBufferSize() {}
+//         public void flushBuffer() throws IOException {}
+//         public boolean isCommitted() {}
+//         public void reset() {}
+//         public void resetBuffer() {}
+//         public void setLocale(Locale loc) {}
+//         public Locale getLocale() {}
+}

http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki/src/main/java/org/apache/jena/fuseki/servlets/NullOutputStream.java
----------------------------------------------------------------------
diff --git a/jena-fuseki/src/main/java/org/apache/jena/fuseki/servlets/NullOutputStream.java b/jena-fuseki/src/main/java/org/apache/jena/fuseki/servlets/NullOutputStream.java
new file mode 100644
index 0000000..63e6562
--- /dev/null
+++ b/jena-fuseki/src/main/java/org/apache/jena/fuseki/servlets/NullOutputStream.java
@@ -0,0 +1,53 @@
+/*
+ * 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.jena.fuseki.servlets;
+
+import java.io.* ;
+
+/** 
+* Code needed to implement an OutputStream that does nothing.
+*/
+
+
+public class NullOutputStream extends /*Filter*/OutputStream
+{
+	public NullOutputStream()
+	{
+	}
+
+	// The OutputStream operations
+	@Override
+    public void close() { /* .close() ;*/ }
+	@Override
+    public void flush() { /* .flush() ;*/ }
+
+	// Need to implement this one.
+	@Override
+    public void write(int b) { /* .write(b) ;*/ }
+	@Override
+    public void write(byte b[]) { /* this.write(b, 0, b.length) ; */}
+
+	// Good to implement this one.
+	@Override
+    public void write(byte[] b, int off, int len)
+	{
+		// Work function
+	}
+	
+}


Mime
View raw message