You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@jena.apache.org by an...@apache.org on 2015/01/05 18:34:23 UTC
[44/51] [abbrv] [partial] jena git commit: Maven modules for Fuseki2
http://git-wip-us.apache.org/repos/asf/jena/blob/470ee4d7/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/server/RequestLog.java
----------------------------------------------------------------------
diff --git a/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/server/RequestLog.java b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/server/RequestLog.java
new file mode 100644
index 0000000..db79d6a
--- /dev/null
+++ b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/server/RequestLog.java
@@ -0,0 +1,148 @@
+/**
+ * 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.text.DateFormat ;
+import java.text.SimpleDateFormat ;
+import java.util.Collection ;
+import java.util.Date ;
+import java.util.Enumeration ;
+import java.util.TimeZone ;
+
+import javax.servlet.http.HttpServletRequest ;
+import javax.servlet.http.HttpServletResponse ;
+
+import org.apache.jena.atlas.logging.Log ;
+import org.apache.jena.fuseki.servlets.HttpAction ;
+
+/** Create standard request logs (NCSA etc) */
+public class RequestLog {
+ /*
+ http://httpd.apache.org/docs/current/mod/mod_log_config.html
+Common Log Format (CLF)
+ "%h %l %u %t \"%r\" %>s %b"
+Common Log Format with Virtual Host
+ "%v %h %l %u %t \"%r\" %>s %b"
+NCSA extended/combined log format
+ "%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-agent}i\""
+ */
+ /*
+ %l -- Identity or -
+ %u -- Remote user or -
+ %t -- Timestamp
+ "%r" -- Request line
+ %>s -- Final request status
+ %b -- Size in bytes
+ Headers.
+ %{}i for request header.
+ %{}o for response header.
+ */
+
+ private static DateFormat dateFormatter ;
+ static {
+ dateFormatter = new SimpleDateFormat("dd/MMM/yyyy:HH:mm:ss Z") ;
+ dateFormatter.setTimeZone(TimeZone.getTimeZone("UTC"));
+ }
+
+ /** NCSA combined log format *
+ * LogFormat "%{X-Forwarded-For}i %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\"" combinedfwd
+ * XXX.XXX.XXX.XXX - - [01/Feb/2014:03:19:09 +0000] "GET / HTTP/1.1" 200 6190 "-" "check_http/v1.4.16 (nagios-plugins 1.4.16)"
+ */
+ public static String combinedNCSA(HttpAction action) {
+ StringBuilder builder = new StringBuilder() ;
+ HttpServletRequest request = action.request ;
+ HttpServletResponse response = action.response ;
+
+ // Remote
+ String remote = get(request, "X-Forwarded-For", request.getRemoteAddr()) ;
+ builder.append(remote) ;
+ builder.append(" ") ;
+
+ // %l %u : User identity (unrelaible)
+ builder.append("- - ") ;
+
+ // %t
+ // Expensive?
+ builder.append("[");
+ // Better?
+ builder.append(dateFormatter.format(new Date())) ;
+ builder.append("] ");
+
+ // "%r"
+ builder.append("\"") ;
+ builder.append(request.getMethod()) ;
+ builder.append(" ") ;
+ // No query string - they are long and logged readably elsewhere
+ builder.append(request.getRequestURI()) ;
+ builder.append("\"") ;
+ //%>s -- Final request status
+ builder.append(" ") ;
+ builder.append(response.getStatus()) ;
+
+ //%b -- Size in bytes
+ builder.append(" ") ;
+ //String size = getField()
+ String size = get(response, "Content-Length", "-") ;
+ builder.append(size) ;
+
+ // "%{Referer}i"
+ builder.append(" \"") ;
+ builder.append(get(request, "Referer", "")) ;
+ builder.append("\"") ;
+ // "%{User-Agent}i"
+ builder.append(" \"") ;
+ builder.append(get(request, "User-Agent", "")) ;
+ builder.append("\"") ;
+
+ return builder.toString() ;
+ }
+
+ private static String get(HttpServletRequest request, String name, String dft) {
+ String x = get(request, name) ;
+ if ( x == null )
+ x = dft ;
+ return x ;
+ }
+
+ private static String get(HttpServletRequest request, String name) {
+ Enumeration<String> en = request.getHeaders(name) ;
+ if ( ! en.hasMoreElements() ) return null ;
+ String x = en.nextElement() ;
+ if ( en.hasMoreElements() ) {
+ Log.warn(RequestLog.class, "Multiple request header values") ;
+ }
+ return x ;
+ }
+
+ private static String get(HttpServletResponse response, String name, String dft) {
+ String x = get(response, name) ;
+ if ( x == null )
+ x = dft ;
+ return x ;
+ }
+
+
+ private static String get(HttpServletResponse response, String name) {
+ Collection<String> en = response.getHeaders(name) ;
+ if ( en.isEmpty() )return null ;
+ if ( en.size() != 1 ) Log.warn(RequestLog.class, "Multiple response header values") ;
+ return response.getHeader(name) ;
+ }
+
+}
http://git-wip-us.apache.org/repos/asf/jena/blob/470ee4d7/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/server/ServerInitialConfig.java
----------------------------------------------------------------------
diff --git a/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/server/ServerInitialConfig.java b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/server/ServerInitialConfig.java
new file mode 100644
index 0000000..67f5d26
--- /dev/null
+++ b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/server/ServerInitialConfig.java
@@ -0,0 +1,40 @@
+/**
+ * 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.HashMap ;
+import java.util.Map ;
+
+import com.hp.hpl.jena.sparql.core.DatasetGraph ;
+
+/** Dataset setup (command line, config file) for a dataset (or several if config file) */
+public class ServerInitialConfig {
+ // Either this ...
+ public String templateFile = null ;
+ public Map<String,String> params = new HashMap<>() ;
+ public String datasetPath = null ;
+ public boolean allowUpdate = false ;
+ // Or this ...
+ public String fusekiConfigFile = null ;
+
+ // Special case - directly pass in the dataset graphs - datasetPath must be given.
+ // This is not persistet across server restarts.
+ public DatasetGraph dsg = null ;
+
+}
http://git-wip-us.apache.org/repos/asf/jena/blob/470ee4d7/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/server/ServiceMXBean.java
----------------------------------------------------------------------
diff --git a/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/server/ServiceMXBean.java b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/server/ServiceMXBean.java
new file mode 100644
index 0000000..11c7330
--- /dev/null
+++ b/jena-fuseki2/jena-fuseki-core/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/470ee4d7/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/server/ShiroEnvironmentLoader.java
----------------------------------------------------------------------
diff --git a/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/server/ShiroEnvironmentLoader.java b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/server/ShiroEnvironmentLoader.java
new file mode 100644
index 0000000..f33fe92
--- /dev/null
+++ b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/server/ShiroEnvironmentLoader.java
@@ -0,0 +1,164 @@
+/**
+ * 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.io.IOException ;
+import java.io.InputStream ;
+import java.nio.file.Path ;
+import java.nio.file.Paths ;
+
+import javax.servlet.ServletContext ;
+import javax.servlet.ServletContextEvent ;
+import javax.servlet.ServletContextListener ;
+
+import org.apache.jena.fuseki.Fuseki ;
+import org.apache.shiro.config.ConfigurationException ;
+import org.apache.shiro.io.ResourceUtils ;
+import org.apache.shiro.web.env.EnvironmentLoader ;
+import org.apache.shiro.web.env.ResourceBasedWebEnvironment ;
+import org.apache.shiro.web.env.WebEnvironment ;
+
+import com.hp.hpl.jena.util.FileUtils ;
+
+/** A place to perform Fuseki-specific initialization of Apache Shiro.
+ * Runs after listener FusekiServerEnvironmentInit and before FusekiServerListener
+ * This means finding shiro.ini in multiple possible places, based on
+ * different deployment setups.
+ */
+public class ShiroEnvironmentLoader extends EnvironmentLoader implements ServletContextListener {
+ private ServletContext servletContext ;
+
+ public ShiroEnvironmentLoader() {}
+
+ @Override
+ public void contextInitialized(ServletContextEvent sce) {
+ FusekiServer.init() ;
+ this.servletContext = sce.getServletContext() ;
+ try {
+ // Shiro.
+ initEnvironment(servletContext);
+ } catch (ConfigurationException ex) {
+ Fuseki.configLog.error("Shiro initialization failed: "+ex.getMessage());
+ // Exit?
+ throw ex ;
+ }
+ }
+
+ @Override
+ public void contextDestroyed(ServletContextEvent sce) {
+ destroyEnvironment(sce.getServletContext());
+ }
+
+ /**
+ * Normal Shiro initialization only supports one location for an INI file.
+ *
+ * When given multiple multiple locations for the shiro.ini file, and
+ * if a {@link ResourceBasedWebEnvironment}, check the list of configuration
+ * locations, testing whether the name identified an existing resource.
+ * For the first resource name found to exist, reset the {@link ResourceBasedWebEnvironment}
+ * to name that resource alone so the normal Shiro initialization
+ */
+ @Override
+ protected void customizeEnvironment(WebEnvironment environment) {
+ if ( environment instanceof ResourceBasedWebEnvironment ) {
+ ResourceBasedWebEnvironment env = (ResourceBasedWebEnvironment)environment ;
+ String[] locations = env.getConfigLocations() ;
+ String loc = huntForShiroIni(locations) ;
+ Fuseki.configLog.info("Shiro file: "+loc);
+ if (loc != null )
+ locations = new String[] {loc} ;
+ env.setConfigLocations(locations);
+ }
+ }
+
+ private static final String FILE = "file" ;
+
+ /** Look for a Shiro ini file, or return null */
+ private static String huntForShiroIni(String[] locations) {
+ FusekiEnv.setEnvironment() ;
+ Fuseki.init();
+ for ( String loc : locations ) {
+ // If file:, look for that file.
+ // If a relative name without scheme, look in FUSEKI_BASE, FUSEKI_HOME, webapp.
+ String scheme = FileUtils.getScheme(loc) ;
+
+ // Covers C:\\ as a "scheme name"
+ if ( scheme != null ) {
+ if ( scheme.equalsIgnoreCase(FILE)) {
+ // Test file: for exists
+ Path p = Paths.get(loc.substring(FILE.length()+1)) ;
+ if ( ! p.toFile().exists() )
+ continue ;
+ // Fall through.
+ }
+ // Can't test - try
+ return loc ;
+ }
+ // No scheme .
+ Path p = Paths.get(loc) ;
+
+ String fn = resolve(FusekiEnv.FUSEKI_BASE, p) ;
+ if ( fn != null )
+ return "file://"+fn ;
+ fn = resolve(FusekiEnv.FUSEKI_HOME, p) ;
+ if ( fn != null )
+ return "file://"+fn ;
+
+ // Try in webapp.
+
+ try ( InputStream is = ResourceUtils.getInputStreamForPath(loc); ) {
+ boolean exists = (is != null ) ;
+ return loc ;
+ } catch (IOException e) { }
+ }
+ return null ;
+ }
+
+ /** Directory + name -> filename if it exists */
+ private static String resolve(Path dir, Path file) {
+ Path p = dir.resolve(file) ;
+ if ( p.toFile().exists() )
+ return p.normalize().toString() ;
+ return null ;
+ }
+
+// /**
+// * Test whether a name identified an existing resource
+// * @param resource A String in Shiro-resource name format (e.g. URL scheme names)
+// * @return True/false as to whether the resource can be found or not.
+// */
+//
+// private boolean resourceExists(String resource) {
+// try {
+// // See IniWebEnvironment.convertPathToIni
+// if (!ResourceUtils.hasResourcePrefix(resource)) {
+// //Sort out "path" and open as a webapp resource.
+// resource = WebUtils.normalize(resource);
+// URL url = servletContext.getResource(resource) ;
+// return ( url == null ) ;
+// } else {
+// // Treat as a plain name.
+// InputStream is = ResourceUtils.getInputStreamForPath(resource);
+// boolean exists = (is != null ) ;
+// is.close() ;
+// return exists ;
+// }
+// } catch (IOException e) { return false ; }
+// }
+}
http://git-wip-us.apache.org/repos/asf/jena/blob/470ee4d7/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/server/SystemState.java
----------------------------------------------------------------------
diff --git a/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/server/SystemState.java b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/server/SystemState.java
new file mode 100644
index 0000000..74117c9
--- /dev/null
+++ b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/server/SystemState.java
@@ -0,0 +1,108 @@
+/**
+ * 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.atlas.lib.FileOps ;
+import org.apache.jena.atlas.lib.StrUtils ;
+import org.apache.jena.fuseki.Fuseki ;
+
+import com.hp.hpl.jena.query.Dataset ;
+import com.hp.hpl.jena.tdb.StoreConnection ;
+import com.hp.hpl.jena.tdb.TDB ;
+import com.hp.hpl.jena.tdb.TDBFactory ;
+import com.hp.hpl.jena.tdb.base.block.FileMode ;
+import com.hp.hpl.jena.tdb.base.file.Location ;
+import com.hp.hpl.jena.tdb.setup.StoreParams ;
+import com.hp.hpl.jena.tdb.transaction.DatasetGraphTransaction ;
+
+public class SystemState {
+ private static String SystemDatabaseLocation ;
+ // Testing may reset this.
+ public static Location location ;
+
+ private static Dataset dataset = null ;
+ private static DatasetGraphTransaction dsg = null ;
+
+ public static Dataset getDataset() {
+ init() ;
+ return dataset ;
+ }
+
+ public static DatasetGraphTransaction getDatasetGraph() {
+ init() ;
+ return dsg ;
+ }
+
+ private static boolean initialized = false ;
+ private static void init() {
+ init$() ;
+ }
+
+ /** Small footprint database. The system database records the server state.
+ * It should not be performance critical, mainly being used for system admin
+ * functions.
+ * <p>Direct mode so that it is not competing for OS file cache space.
+ * <p>Small caches -
+ */
+ private static final StoreParams systemDatabaseParams = StoreParams.builder()
+ .fileMode(FileMode.direct)
+ .blockReadCacheSize(20)
+ .blockWriteCacheSize(20)
+ .node2NodeIdCacheSize(5000)
+ .nodeId2NodeCacheSize(5000)
+ .nodeMissCacheSize(100)
+ .build() ;
+
+ public /* for testing */ static void init$() {
+ if ( initialized )
+ return ;
+ initialized = true ;
+
+ if ( location == null )
+ location = Location.create(FusekiServer.dirSystemDatabase.toString()) ;
+
+ if ( ! location.isMem() )
+ FileOps.ensureDir(location.getDirectoryPath()) ;
+
+ // Force it into the store connection as a low footprint
+ if ( StoreConnection.getExisting(location) != null )
+ Fuseki.serverLog.warn("System database already in the StoreConnection cache") ;
+ StoreConnection.make(location, systemDatabaseParams) ;
+
+ dataset = TDBFactory.createDataset(location) ;
+ dsg = (DatasetGraphTransaction)(dataset.asDatasetGraph()) ;
+ dsg.getContext().set(TDB.symUnionDefaultGraph, false) ;
+ }
+
+ public static String PREFIXES = StrUtils.strjoinNL
+ ("BASE <http://example/base#>",
+ "PREFIX ja: <http://jena.hpl.hp.com/2005/11/Assembler#>",
+ "PREFIX fu: <http://jena.apache.org/fuseki#>",
+ "PREFIX fuseki: <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 sdb: <http://jena.hpl.hp.com/20087/sdb#>",
+ "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#>",
+ "") ;
+}
+
http://git-wip-us.apache.org/repos/asf/jena/blob/470ee4d7/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ActionBase.java
----------------------------------------------------------------------
diff --git a/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ActionBase.java b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ActionBase.java
new file mode 100644
index 0000000..3e45c78
--- /dev/null
+++ b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ActionBase.java
@@ -0,0 +1,265 @@
+/*
+ * 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 java.lang.String.format ;
+
+import java.io.IOException ;
+import java.util.Enumeration ;
+import java.util.Map ;
+
+import javax.servlet.ServletException ;
+import javax.servlet.http.HttpServletRequest ;
+import javax.servlet.http.HttpServletResponse ;
+
+import org.apache.jena.atlas.RuntimeIOException ;
+import org.apache.jena.fuseki.Fuseki ;
+import org.apache.jena.riot.web.HttpNames ;
+import org.apache.jena.web.HttpSC ;
+import org.slf4j.Logger ;
+
+import com.hp.hpl.jena.query.ARQ ;
+import com.hp.hpl.jena.query.QueryCancelledException ;
+import com.hp.hpl.jena.sparql.util.Context ;
+
+/** General request lifecycle */
+public abstract class ActionBase extends ServletBase
+{
+ protected final Logger log ;
+
+ protected ActionBase(Logger log) {
+ super() ;
+ this.log = log ;
+ }
+
+ @Override
+ public void init() {
+// log.info("["+Utils.className(this)+"] ServletContextName = "+getServletContext().getServletContextName()) ;
+// log.info("["+Utils.className(this)+"] ContextPath = "+getServletContext().getContextPath()) ;
+
+ //super.init() ;
+ }
+
+ /**
+ * Common framework for handling HTTP requests.
+ * @param request
+ * @param response
+ */
+ protected void doCommon(HttpServletRequest request, HttpServletResponse response)
+ {
+ try {
+ long id = allocRequestId(request, response);
+
+ // Lifecycle
+ HttpAction action = allocHttpAction(id, request, response) ;
+
+ printRequest(action) ;
+ action.setStartTime() ;
+
+ // The response may be changed to a HttpServletResponseTracker
+ response = action.response ;
+ initResponse(request, response) ;
+ Context cxt = ARQ.getContext() ;
+
+ try {
+ execCommonWorker(action) ;
+ } catch (QueryCancelledException ex) {
+ // Also need the per query info ...
+ String message = String.format("The query timed out (restricted to %s ms)", cxt.get(ARQ.queryTimeout));
+ // Possibility :: response.setHeader("Retry-after", "600") ; // 5 minutes
+ ServletOps.responseSendError(response, HttpSC.SERVICE_UNAVAILABLE_503, message);
+ } catch (ActionErrorException ex) {
+ if ( ex.exception != null )
+ ex.exception.printStackTrace(System.err) ;
+ // Log message done by printResponse in a moment.
+ if ( ex.message != null )
+ ServletOps.responseSendError(response, ex.rc, ex.message) ;
+ else
+ ServletOps.responseSendError(response, ex.rc) ;
+ } catch (RuntimeIOException ex) {
+ log.warn(format("[%d] Runtime IO Exception (client left?) RC = %d : %s", id, HttpSC.INTERNAL_SERVER_ERROR_500, ex.getMessage()), ex) ;
+ ServletOps.responseSendError(response, HttpSC.INTERNAL_SERVER_ERROR_500, ex.getMessage()) ;
+ } catch (Throwable ex) {
+ // This should not happen.
+ //ex.printStackTrace(System.err) ;
+ log.warn(format("[%d] RC = %d : %s", id, HttpSC.INTERNAL_SERVER_ERROR_500, ex.getMessage()), ex) ;
+ ServletOps.responseSendError(response, HttpSC.INTERNAL_SERVER_ERROR_500, ex.getMessage()) ;
+ }
+
+ action.setFinishTime() ;
+ printResponse(action) ;
+ archiveHttpAction(action) ;
+ } catch (Throwable th) {
+ log.error("Internal error", th) ;
+ }
+ }
+
+ // ---- Operation lifecycle
+
+ /**
+ * Returns a fresh HTTP Action for this request.
+ * @param id the Request ID
+ * @param request HTTP request
+ * @param response HTTP response
+ * @return a new HTTP Action
+ */
+ protected HttpAction allocHttpAction(long id, HttpServletRequest request, HttpServletResponse response) {
+ // Need a way to set verbose logging on a per servlet and per request basis.
+ return new HttpAction(id, log, request, response, Fuseki.verboseLogging) ;
+ }
+
+ /**
+ * Begin handling an {@link HttpAction}
+ * @param action
+ */
+ protected final void startRequest(HttpAction action) {
+ action.startRequest() ;
+ }
+
+ /**
+ * Stop handling an {@link HttpAction}
+ */
+ protected final void finishRequest(HttpAction action) {
+ action.finishRequest() ;
+ }
+
+ /**
+ * Archives the HTTP Action.
+ * @param action HTTP Action
+ * @see HttpAction#minimize()
+ */
+ private void archiveHttpAction(HttpAction action) {
+ action.minimize() ;
+ }
+
+ /**
+ * Execute this request, which maybe a admin operation or a client request.
+ * @param action HTTP Action
+ */
+ protected abstract void execCommonWorker(HttpAction action) ;
+
+ /** Extract the name after the container name (serverlet name).
+ * Returns "/name" or null
+ */
+ protected static String extractItemName(HttpAction action) {
+// action.log.info("context path = "+action.request.getContextPath()) ;
+// action.log.info("pathinfo = "+action.request.getPathInfo()) ;
+// action.log.info("servlet path = "+action.request.getServletPath()) ;
+ // if /name
+ // request.getServletPath() otherwise it's null
+ // if /*
+ // request.getPathInfo() ; otherwise it's null.
+
+ // PathInfo is after the servlet name.
+ String x1 = action.request.getServletPath() ;
+ String x2 = action.request.getPathInfo() ;
+
+ String pathInfo = action.request.getPathInfo() ;
+ if ( pathInfo == null || pathInfo.isEmpty() || pathInfo.equals("/") )
+ // Includes calling as a container.
+ return null ;
+ String name = pathInfo ;
+ // pathInfo starts with a "/"
+ int idx = pathInfo.lastIndexOf('/') ;
+ if ( idx > 0 )
+ name = name.substring(idx) ;
+ // Returns "/name"
+ return name ;
+ }
+
+ @SuppressWarnings("unused") // ServletException
+ protected void doPatch(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+ response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, "HTTP PATCH not supported");
+ }
+
+ private void printRequest(HttpAction action) {
+ String url = ActionLib.wholeRequestURL(action.request) ;
+ String method = action.request.getMethod() ;
+
+ log.info(format("[%d] %s %s", action.id, method, url)) ;
+ if ( action.verbose ) {
+ Enumeration<String> en = action.request.getHeaderNames() ;
+ for (; en.hasMoreElements();) {
+ String h = en.nextElement() ;
+ Enumeration<String> vals = action.request.getHeaders(h) ;
+ if ( !vals.hasMoreElements() )
+ log.info(format("[%d] ", action.id, h)) ;
+ else {
+ for (; vals.hasMoreElements();)
+ log.info(format("[%d] %-20s %s", action.id, h, vals.nextElement())) ;
+ }
+ }
+ }
+ }
+
+ private void initResponse(HttpServletRequest request, HttpServletResponse response) {
+ setCommonHeaders(response) ;
+ String method = request.getMethod() ;
+ // All GET and HEAD operations are sensitive to conneg so ...
+ if ( HttpNames.METHOD_GET.equalsIgnoreCase(method) || HttpNames.METHOD_HEAD.equalsIgnoreCase(method) )
+ setVaryHeader(response) ;
+ }
+
+ private void printResponse(HttpAction action) {
+ long time = action.getTime() ;
+
+ HttpServletResponseTracker response = action.response ;
+ if ( action.verbose ) {
+ if ( action.contentType != null )
+ log.info(format("[%d] %-20s %s", action.id, HttpNames.hContentType, action.contentType)) ;
+ if ( action.contentLength != -1 )
+ log.info(format("[%d] %-20s %d", action.id, HttpNames.hContentLengh, action.contentLength)) ;
+ for (Map.Entry<String, String> e : action.headers.entrySet())
+ log.info(format("[%d] %-20s %s", action.id, e.getKey(), e.getValue())) ;
+ }
+
+ String timeStr = fmtMillis(time) ;
+
+ if ( action.message == null )
+ log.info(String.format("[%d] %d %s (%s) ", action.id, action.statusCode,
+ HttpSC.getMessage(action.statusCode), timeStr)) ;
+ else
+ log.info(String.format("[%d] %d %s (%s) ", action.id, action.statusCode, action.message, timeStr)) ;
+
+ // See also HttpAction.finishRequest - request logging happens there.
+ }
+
+ /**
+ * <p>Given a time point, return the time as a milli second string if it is less than 1000,
+ * otherwise return a seconds string.</p>
+ * <p>It appends a 'ms' suffix when using milli seconds,
+ * and <i>s</i> for seconds.</p>
+ * <p>For instance: </p>
+ * <ul>
+ * <li>10 emits 10 ms</li>
+ * <li>999 emits 999 ms</li>
+ * <li>1000 emits 1.000 s</li>
+ * <li>10000 emits 10.000 s</li>
+ * </ul>
+ * @param time the time in milliseconds
+ * @return the time as a display string
+ */
+
+ private static String fmtMillis(long time) {
+ // Millis only? seconds only?
+ if ( time < 1000 )
+ return String.format("%,d ms", time) ;
+ return String.format("%,.3f s", time / 1000.0) ;
+ }
+}
http://git-wip-us.apache.org/repos/asf/jena/blob/470ee4d7/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ActionErrorException.java
----------------------------------------------------------------------
diff --git a/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ActionErrorException.java b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ActionErrorException.java
new file mode 100644
index 0000000..c87cfe8
--- /dev/null
+++ b/jena-fuseki2/jena-fuseki-core/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;
+
+public class ActionErrorException extends RuntimeException
+{
+ public final Throwable exception ;
+ public final String message ;
+ public final int rc ;
+ public 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/470ee4d7/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ActionLib.java
----------------------------------------------------------------------
diff --git a/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ActionLib.java b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ActionLib.java
new file mode 100644
index 0000000..182b46e
--- /dev/null
+++ b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ActionLib.java
@@ -0,0 +1,180 @@
+/**
+ * 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 javax.servlet.http.HttpServletRequest ;
+
+import org.apache.jena.atlas.web.AcceptList ;
+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.DataAccessPoint ;
+import org.apache.jena.fuseki.server.DataAccessPointRegistry ;
+
+/** Operations related to servlets */
+
+public class ActionLib {
+ /**
+ * A possible implementation for {@link ActionSPARQL#mapRequestToDataset}
+ * that assumes the form /dataset/service.
+ * @param action the request
+ * @return the dataset
+ */ public static String mapRequestToDataset(HttpAction action) {
+ String uri = action.getActionURI() ;
+ return mapActionRequestToDataset(uri) ;
+ }
+
+ /** Map request to uri in the registry.
+ * A possible implementation for mapRequestToDataset(String)
+ * that assumes the form /dataset/service
+ * Returning null means no mapping found.
+ * The URI must be the action URI (no contact path)
+ */
+
+ public static String mapActionRequestToDataset(String uri) {
+ // Chop off trailing part - the service selector
+ // e.g. /dataset/sparql => /dataset
+ int i = uri.lastIndexOf('/') ;
+ if ( i == -1 )
+ return null ;
+ if ( i == 0 )
+ {
+ // started with '/' - leave.
+ return uri ;
+ }
+
+ return uri.substring(0, i) ;
+ }
+
+ /** Calculate the operation , given action and data access point */
+ public static String mapRequestToOperation(HttpAction action, DataAccessPoint dsRef) {
+ if ( dsRef == null )
+ return "" ;
+ String uri = action.getActionURI() ;
+ String name = dsRef.getName();
+ if ( name.length() >= uri.length() )
+ return "" ;
+ return uri.substring(name.length()+1) ; // Skip the separating "/"
+
+ }
+
+ /** Implementation of mapRequestToDataset(String) that looks for
+ * the longest match in the registry.
+ * This includes use in direct naming GSP.
+ */
+ public static String mapRequestToDatasetLongest$(String uri)
+ {
+ if ( uri == null )
+ return null ;
+
+ // This covers local, using the URI as a direct name for
+ // a graph, not just using the indirect ?graph= or ?default
+ // forms.
+
+ String ds = null ;
+ for ( String ds2 : DataAccessPointRegistry.get().keys() ) {
+ if ( ! uri.startsWith(ds2) )
+ continue ;
+
+ if ( ds == null )
+ {
+ ds = ds2 ;
+ continue ;
+ }
+ if ( ds.length() < ds2.length() )
+ {
+ ds = ds2 ;
+ continue ;
+ }
+ }
+ return ds ;
+ }
+
+ /** Calculate the fill URL including query string
+ * for the HTTP request. This may be quite long.
+ * @param request HttpServletRequest
+ * @return String The full URL, including query string.
+ */
+ public static String wholeRequestURL(HttpServletRequest request) {
+ StringBuffer sb = request.getRequestURL() ;
+ String queryString = request.getQueryString() ;
+ if ( queryString != null ) {
+ sb.append("?") ;
+ sb.append(queryString) ;
+ }
+ return sb.toString() ;
+ }
+
+ /*
+ * The context path can be:
+ * "" for the root context
+ * "/APP" for named contexts
+ * so:
+ * "/dataset/server" becomes "/dataset/server"
+ * "/APP/dataset/server" becomes "/dataset/server"
+ */
+ public static String removeContextPath(HttpAction action) {
+
+ return actionURI(action.request) ;
+ }
+
+ public static String actionURI(HttpServletRequest request) {
+// Log.info(this, "URI = '"+request.getRequestURI()) ;
+// Log.info(this, "Context path = '"+request.getContextPath()+"'") ;
+// Log.info(this, "Servlet path = '"+request.getServletPath()+"'") ;
+// ServletContext cxt = this.getServletContext() ;
+// Log.info(this, "ServletContext path = '"+cxt.getContextPath()+"'") ;
+
+ String contextPath = request.getServletContext().getContextPath() ;
+ String uri = request.getRequestURI() ;
+ if ( contextPath == null )
+ return uri ;
+ if ( contextPath.isEmpty())
+ return uri ;
+ String x = uri ;
+ if ( uri.startsWith(contextPath) )
+ x = uri.substring(contextPath.length()) ;
+ //log.info("uriWithoutContextPath: uri = "+uri+" contextPath="+contextPath+ "--> x="+x) ;
+ return x ;
+ }
+
+ /** Negotiate the content-type and set the response headers */
+ public static MediaType contentNegotation(HttpAction action, AcceptList myPrefs,
+ MediaType defaultMediaType) {
+ MediaType mt = ConNeg.chooseContentType(action.request, myPrefs, defaultMediaType) ;
+ 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 ;
+ }
+
+ /** Negotiate the content-type for an RDF triples syntax and set the response headers */
+ public static MediaType contentNegotationRDF(HttpAction action) {
+ return contentNegotation(action, DEF.rdfOffer, DEF.acceptRDFXML) ;
+ }
+
+ /** Negotiate the content-type for an RDF quads syntax and set the response headers */
+ public static MediaType contentNegotationQuads(HttpAction action) {
+ return contentNegotation(action, DEF.quadsOffer, DEF.acceptNQuads) ;
+ }
+}
+
http://git-wip-us.apache.org/repos/asf/jena/blob/470ee4d7/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ActionREST.java
----------------------------------------------------------------------
diff --git a/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ActionREST.java b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ActionREST.java
new file mode 100644
index 0000000..e2c7e4a
--- /dev/null
+++ b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ActionREST.java
@@ -0,0 +1,161 @@
+/*
+ * 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 java.util.Locale ;
+
+import javax.servlet.ServletException ;
+import javax.servlet.http.HttpServletRequest ;
+import javax.servlet.http.HttpServletResponse ;
+
+import org.apache.jena.fuseki.server.CounterName ;
+
+/** Common point for operations that are "REST"ish (use GET/PUT etc as operations). */
+public abstract class ActionREST extends ActionSPARQL
+{
+ public ActionREST()
+ { super() ; }
+
+ @Override
+ protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+ // Direct all verbs to our common framework.
+ doCommon(request, response) ;
+ }
+
+ @Override
+ protected void perform(HttpAction action) {
+ dispatch(action) ;
+ }
+
+ private void dispatch(HttpAction action) {
+ HttpServletRequest req = action.request ;
+ HttpServletResponse resp = action.response ;
+ String method = req.getMethod().toUpperCase(Locale.ROOT) ;
+
+ if (method.equals(METHOD_GET))
+ doGet$(action);
+ else if (method.equals(METHOD_HEAD))
+ doHead$(action);
+ else if (method.equals(METHOD_POST))
+ doPost$(action);
+ else if (method.equals(METHOD_PATCH))
+ doPatch$(action) ;
+ else if (method.equals(METHOD_OPTIONS))
+ doOptions$(action) ;
+ else if (method.equals(METHOD_TRACE))
+ //doTrace(action) ;
+ ServletOps.errorMethodNotAllowed("TRACE") ;
+ else if (method.equals(METHOD_PUT))
+ doPut$(action) ;
+ else if (method.equals(METHOD_DELETE))
+ doDelete$(action) ;
+ else
+ ServletOps.errorNotImplemented("Unknown method: "+method) ;
+ }
+
+ // Counter wrappers
+
+ // XXX Out of date - we now add HTTP counters to all endpoints.
+
+ private final void doGet$(HttpAction action) {
+ incCounter(action.getEndpoint(), CounterName.HTTPget) ;
+ try {
+ doGet(action) ;
+ incCounter(action.getEndpoint(), CounterName.HTTPgetGood) ;
+ } catch ( ActionErrorException ex) {
+ incCounter(action.getEndpoint(), CounterName.HTTPGetBad) ;
+ throw ex ;
+ }
+ }
+
+ private final void doHead$(HttpAction action) {
+ incCounter(action.getEndpoint(), CounterName.HTTPhead) ;
+ try {
+ doHead(action) ;
+ incCounter(action.getEndpoint(), CounterName.HTTPheadGood) ;
+ } catch ( ActionErrorException ex) {
+ incCounter(action.getEndpoint(), CounterName.HTTPheadBad) ;
+ throw ex ;
+ }
+ }
+
+ private final void doPost$(HttpAction action) {
+ incCounter(action.getEndpoint(), CounterName.HTTPpost) ;
+ try {
+ doPost(action) ;
+ incCounter(action.getEndpoint(), CounterName.HTTPpostGood) ;
+ } catch ( ActionErrorException ex) {
+ incCounter(action.getEndpoint(), CounterName.HTTPpostBad) ;
+ throw ex ;
+ }
+ }
+
+ private final void doPatch$(HttpAction action) {
+ incCounter(action.getEndpoint(), CounterName.HTTPpatch) ;
+ try {
+ doPatch(action) ;
+ incCounter(action.getEndpoint(), CounterName.HTTPpatchGood) ;
+ } catch ( ActionErrorException ex) {
+ incCounter(action.getEndpoint(), CounterName.HTTPpatchBad) ;
+ throw ex ;
+ }
+ }
+
+ private final void doDelete$(HttpAction action) {
+ incCounter(action.getEndpoint(), CounterName.HTTPdelete) ;
+ try {
+ doDelete(action) ;
+ incCounter(action.getEndpoint(), CounterName.HTTPdeleteGood) ;
+ } catch ( ActionErrorException ex) {
+ incCounter(action.getEndpoint(), CounterName.HTTPdeleteBad) ;
+ throw ex ;
+ }
+ }
+
+ private final void doPut$(HttpAction action) {
+ incCounter(action.getEndpoint(), CounterName.HTTPput) ;
+ try {
+ doPut(action) ;
+ incCounter(action.getEndpoint(), CounterName.HTTPputGood) ;
+ } catch ( ActionErrorException ex) {
+ incCounter(action.getEndpoint(), CounterName.HTTPputBad) ;
+ throw ex ;
+ }
+ }
+
+ private final void doOptions$(HttpAction action) {
+ incCounter(action.getEndpoint(), CounterName.HTTPoptions) ;
+ try {
+ doOptions(action) ;
+ incCounter(action.getEndpoint(), CounterName.HTTPoptionsGood) ;
+ } catch ( ActionErrorException ex) {
+ incCounter(action.getEndpoint(), CounterName.HTTPoptionsBad) ;
+ throw ex ;
+ }
+ }
+
+ protected abstract void doGet(HttpAction action) ;
+ protected abstract void doHead(HttpAction action) ;
+ protected abstract void doPost(HttpAction action) ;
+ protected abstract void doPatch(HttpAction action) ;
+ protected abstract void doDelete(HttpAction action) ;
+ protected abstract void doPut(HttpAction action) ;
+ protected abstract void doOptions(HttpAction action) ;
+}
http://git-wip-us.apache.org/repos/asf/jena/blob/470ee4d7/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ActionSPARQL.java
----------------------------------------------------------------------
diff --git a/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ActionSPARQL.java b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ActionSPARQL.java
new file mode 100644
index 0000000..d26bc55
--- /dev/null
+++ b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ActionSPARQL.java
@@ -0,0 +1,207 @@
+/*
+ * 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 org.apache.jena.fuseki.server.CounterName.Requests ;
+import static org.apache.jena.fuseki.server.CounterName.RequestsBad ;
+import static org.apache.jena.fuseki.server.CounterName.RequestsGood ;
+
+import java.io.InputStream ;
+
+import org.apache.jena.atlas.RuntimeIOException ;
+import org.apache.jena.fuseki.Fuseki ;
+import org.apache.jena.fuseki.server.* ;
+import org.apache.jena.riot.Lang ;
+import org.apache.jena.riot.RDFDataMgr ;
+import org.apache.jena.riot.ReaderRIOT ;
+import org.apache.jena.riot.RiotException ;
+import org.apache.jena.riot.system.ErrorHandler ;
+import org.apache.jena.riot.system.ErrorHandlerFactory ;
+import org.apache.jena.riot.system.StreamRDF ;
+
+import com.hp.hpl.jena.query.QueryCancelledException ;
+
+/** SPARQL request lifecycle */
+public abstract class ActionSPARQL extends ActionBase
+{
+ protected ActionSPARQL() { super(Fuseki.actionLog) ; }
+
+ protected abstract void validate(HttpAction action) ;
+ protected abstract void perform(HttpAction action) ;
+
+ /**
+ * Executes common tasks, including mapping the request to the right dataset, setting the dataset into the HTTP
+ * action, and retrieving the service for the dataset requested. Finally, it calls the
+ * {@link #executeAction(HttpAction)} method, which executes the HTTP Action life cycle.
+ * @param action HTTP Action
+ */
+ @Override
+ protected void execCommonWorker(HttpAction action) {
+ DataAccessPoint dataAccessPoint ;
+ DataService dSrv ;
+
+ String datasetUri = mapRequestToDataset(action) ;
+ if ( datasetUri != null ) {
+ dataAccessPoint = DataAccessPointRegistry.get().get(datasetUri) ;
+ if ( dataAccessPoint == null ) {
+ ServletOps.errorNotFound("No dataset for URI: "+datasetUri) ;
+ return ;
+ }
+ //dataAccessPoint.
+ dSrv = dataAccessPoint.getDataService() ;
+ if ( ! dSrv.isAcceptingRequests() ) {
+ ServletOps.errorNotFound("Dataset not active: "+datasetUri) ;
+ return ;
+ }
+ } else {
+ dataAccessPoint = null ;
+ dSrv = DataService.serviceOnlyDataService() ;
+ }
+
+ String operationName = mapRequestToOperation(action, dataAccessPoint) ;
+ action.setRequest(dataAccessPoint, dSrv) ;
+
+ //operationName = ""
+
+ Endpoint op = dSrv.getOperation(operationName) ;
+ action.setEndpoint(op, operationName);
+ executeAction(action) ;
+ }
+
+ /** Execute a SPARQL request. Statistics have not been adjusted at this point.
+ *
+ * @param action
+ */
+ protected void executeAction(HttpAction action) {
+ executeLifecycle(action) ;
+ }
+
+ /**
+ * Standard execution lifecycle for a SPARQL Request.
+ * <ul>
+ * <li>{@link #startRequest(HttpAction)}</li>
+ * <li>initial statistics,</li>
+ * <li>{@link #validate(HttpAction)} request,</li>
+ * <li>{@link #perform(HttpAction)} request,</li>
+ * <li>completion/error statistics,</li>
+ * <li>{@link #finishRequest(HttpAction)}
+ * </ul>
+ *
+ * @param action
+ */
+ // This is the service request lifecycle.
+ final
+ protected void executeLifecycle(HttpAction action) {
+ startRequest(action) ;
+ // And also HTTP counter
+ CounterSet csService = action.getDataService().getCounters() ;
+ CounterSet csOperation = action.getEndpoint().getCounters() ;
+
+ incCounter(csService, Requests) ;
+ incCounter(csOperation, Requests) ;
+ try {
+ // Either exit this via "bad request" on validation
+ // or in execution in perform.
+ try {
+ validate(action) ;
+ } catch (ActionErrorException ex) {
+ incCounter(csOperation, RequestsBad) ;
+ incCounter(csService, RequestsBad) ;
+ throw ex ;
+ }
+
+ try {
+ perform(action) ;
+ // Success
+ incCounter(csOperation, RequestsGood) ;
+ incCounter(csService, RequestsGood) ;
+ } catch (ActionErrorException | QueryCancelledException | RuntimeIOException ex) {
+ incCounter(csOperation, RequestsBad) ;
+ incCounter(csService, RequestsBad) ;
+ throw ex ;
+ }
+ } finally {
+ finishRequest(action) ;
+ }
+ }
+
+ /**
+ * Map request {@link HttpAction} to uri in the registry.
+ * A return of ull means no mapping done (passthrough).
+ * @param uri the URI
+ * @return the dataset
+ */
+ protected String mapRequestToDataset(HttpAction action) {
+ return ActionLib.mapRequestToDataset(action) ;
+ }
+
+ /**
+ * Map request to uri in the registry. null means no mapping done
+ * (passthrough).
+ */
+ protected String mapRequestToOperation(HttpAction action, DataAccessPoint dataAccessPoint) {
+ return ActionLib.mapRequestToOperation(action, dataAccessPoint) ;
+ }
+
+ /** Increment counter */
+ protected static void incCounter(Counters counters, CounterName name) {
+ if ( counters == null ) return ;
+ incCounter(counters.getCounters(), name) ;
+ }
+
+ /** Decrement counter */
+ protected static void decCounter(Counters counters, CounterName name) {
+ if ( counters == null ) return ;
+ decCounter(counters.getCounters(), name) ;
+ }
+
+ protected static void incCounter(CounterSet counters, CounterName name) {
+ if ( counters == null )
+ return ;
+ try {
+ if ( counters.contains(name) )
+ counters.inc(name) ;
+ } catch (Exception ex) {
+ Fuseki.serverLog.warn("Exception on counter inc", ex) ;
+ }
+ }
+
+ protected static void decCounter(CounterSet counters, CounterName name) {
+ if ( counters == null )
+ return ;
+ try {
+ if ( counters.contains(name) )
+ counters.dec(name) ;
+ } catch (Exception ex) {
+ Fuseki.serverLog.warn("Exception on counter dec", ex) ;
+ }
+ }
+
+ public static void parse(HttpAction action, StreamRDF dest, InputStream input, Lang lang, String base) {
+ try {
+ ReaderRIOT r = RDFDataMgr.createReader(lang) ;
+ if ( r == null )
+ ServletOps.errorBadRequest("No parser for language '"+lang.getName()+"'") ;
+ ErrorHandler errorHandler = ErrorHandlerFactory.errorHandlerStd(action.log);
+ r.setErrorHandler(errorHandler);
+ r.read(input, base, null, dest, null) ;
+ }
+ catch (RiotException ex) { ServletOps.errorBadRequest("Parse error: "+ex.getMessage()) ; }
+ }
+}
http://git-wip-us.apache.org/repos/asf/jena/blob/470ee4d7/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ConcurrencyPolicyMRSW.java
----------------------------------------------------------------------
diff --git a/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ConcurrencyPolicyMRSW.java b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/ConcurrencyPolicyMRSW.java
new file mode 100644
index 0000000..1f86539
--- /dev/null
+++ b/jena-fuseki2/jena-fuseki-core/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.actionLog ; //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/470ee4d7/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/FusekiFilter.java
----------------------------------------------------------------------
diff --git a/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/FusekiFilter.java b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/FusekiFilter.java
new file mode 100644
index 0000000..7a79cd3
--- /dev/null
+++ b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/FusekiFilter.java
@@ -0,0 +1,87 @@
+/**
+ * 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.* ;
+import javax.servlet.http.HttpServletRequest ;
+import javax.servlet.http.HttpServletResponse ;
+
+import org.apache.jena.fuseki.Fuseki ;
+import org.apache.jena.fuseki.server.DataAccessPointRegistry ;
+import org.slf4j.Logger ;
+
+/** Look at all requests and see if they match a registered dataset name;
+ * if they do, pass down to the uber servlet, which can dispatch any request
+ * for any service.
+ */
+public class FusekiFilter implements Filter {
+ private static Logger log = Fuseki.serverLog ;
+ private static SPARQL_UberServlet überServlet = new SPARQL_UberServlet.AccessByConfig() ;
+
+ @Override
+ public void init(FilterConfig filterConfig) throws ServletException {
+// log.info("Filter: ["+Utils.className(this)+"] ServletContextName = "+filterConfig.getServletContext().getServletContextName()) ;
+// log.info("Filter: ["+Utils.className(this)+"] ContextPath = "+filterConfig.getServletContext().getContextPath()) ;
+ }
+
+ private static final boolean LogFilter = false ; // Development debugging (can be excessive!)
+
+ @Override
+ public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
+ throws IOException, ServletException {
+ try {
+ HttpServletRequest req = (HttpServletRequest)request ;
+ HttpServletResponse resp = (HttpServletResponse)response ;
+
+ // Handle context path
+ String uri = ActionLib.actionURI(req) ;
+ String datasetUri = ActionLib.mapActionRequestToDataset(uri) ;
+
+ // is it a long running operation?
+ // (this could be a separate filter)
+
+ if ( LogFilter ) {
+ log.info("Filter: Request URI = "+req.getRequestURI()) ;
+ log.info("Filter: Action URI = "+uri) ;
+ log.info("Filter: Dataset URI = "+datasetUri) ;
+ }
+
+ if ( datasetUri != null ) {
+ if ( DataAccessPointRegistry.get().isRegistered(datasetUri) ) {
+ if ( LogFilter )
+ log.info("Filter: dispatch") ;
+ überServlet.doCommon(req, resp) ;
+ return ;
+ }
+ }
+ } catch (Exception ex) {}
+
+ if ( LogFilter )
+ log.info("Filter: pass to chain") ;
+ // Not found - continue.
+ chain.doFilter(request, response);
+ }
+
+ @Override
+ public void destroy() {}
+
+}
+
http://git-wip-us.apache.org/repos/asf/jena/blob/470ee4d7/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/HttpAction.java
----------------------------------------------------------------------
diff --git a/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/HttpAction.java b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/HttpAction.java
new file mode 100644
index 0000000..245ed0f
--- /dev/null
+++ b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/HttpAction.java
@@ -0,0 +1,387 @@
+/*
+ * 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.fuseki.Fuseki ;
+import org.apache.jena.fuseki.FusekiException ;
+import org.apache.jena.fuseki.server.* ;
+import org.slf4j.Logger ;
+
+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 ActionSPARQL#executeAction(HttpAction)} method.
+ */
+public class HttpAction
+{
+ public final long id ;
+ public final boolean verbose ;
+ public final Logger log ;
+
+ // ----
+ // Worth subclassing? Given this is allocated in the general lifecycle
+ // it would mean there are downcasts to the specific type.
+
+ // -- Valid only for operational actions (e.g. SPARQL).
+
+ public String endpointName = null ; // Endpoint name srv was found under
+ public Endpoint endpoint = null ;
+ private Transactional transactional = null ;
+ private boolean isTransactional = false ;
+ private DatasetGraph activeDSG = null ; // Set when inside begin/end.
+ private ReadWrite activeMode = null ; // Set when inside begin/end.
+
+ // -- Valid only for administration actions.
+
+ // -- Shared items (but exact meaning may differ)
+ /** Handle to dataset+services being acted on (maybe null) */
+ private DataAccessPoint dataAccessPoint = null ;
+ private DataService dataService = null ;
+ private String datasetName = null ; // Dataset URI used (e.g. registry)
+ private DatasetGraph dsg = null ;
+
+ // ----
+
+ private boolean startTimeIsSet = false ;
+ private boolean finishTimeIsSet = false ;
+
+ private long startTime = -2 ;
+ private long finishTime = -2 ;
+
+ // Outcome.
+ public int statusCode = -1 ;
+ public String message = null ;
+ public int contentLength = -1 ;
+ public String contentType = null ;
+
+ // Cleared to archive:
+ public Map <String, String> headers = new HashMap<>() ;
+ public HttpServletRequest request;
+ public HttpServletResponseTracker response ;
+ private final String actionURI ;
+ private final String contextPath ;
+
+ /**
+ * Creates a new HTTP Action, using the HTTP request and response, and a given ID.
+ *
+ * @param id given ID
+ * @param log Logger for this action
+ * @param request HTTP request
+ * @param response HTTP response
+ * @param verbose verbose flag
+ */
+ public HttpAction(long id, Logger log, HttpServletRequest request, HttpServletResponse response, boolean verbose) {
+ this.id = id ;
+ this.log = log ;
+ 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 ;
+ this.contextPath = request.getServletContext().getContextPath() ;
+ this.actionURI = ActionLib.actionURI(request) ;
+ }
+
+ /** Initialization after action creation during lifecycle setup.
+ * <p>Sets the action dataset. Setting will replace any existing {@link DataAccessPoint} and {@link DataService},
+ * 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 dataAccessPoint {@link DataAccessPoint}
+ * @param dService {@link DataService}
+ * @see Transactional
+ */
+
+ public void setRequest(DataAccessPoint dataAccessPoint, DataService dService) {
+ this.dataAccessPoint = dataAccessPoint ;
+ if ( dataAccessPoint != null )
+ this.datasetName = dataAccessPoint.getName() ;
+
+ if ( this.dataService != null )
+ throw new FusekiException("Redefinition of DatasetRef in the request action") ;
+
+ this.dataService = dService ;
+ if ( dService == null || dService.getDataset() == null )
+ // Null does not happens for service requests, (it does for admin requests - call setControlRequest)
+ throw new FusekiException("Null DataService in the request action") ;
+
+ this.dsg = dService.getDataset() ;
+ 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 safesetControlRef
+ transactional = new DatasetGraphWithLock(dsg) ;
+ // No real abort.
+ isTransactional = false ;
+ }
+ }
+
+ public void setControlRequest(DataAccessPoint dataAccessPoint, String datasetUri) {
+ this.dataAccessPoint = dataAccessPoint ;
+ this.dataService = null ;
+ this.datasetName = datasetUri ;
+ }
+
+ /**
+ * 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 ;
+ }
+
+ /** This is the requestURI with the context path removed.
+ * It should be used internally for dispatch.
+ */
+ public String getActionURI() {
+ return actionURI ;
+ }
+
+ /** Get the context path.
+ */
+ public String getContextPath() {
+ return contextPath ;
+ }
+
+
+ /** Set the endpoint and endpoint name that this is an action for.
+ * @param srvRef {@link Endpoint}
+ * @param endpointName
+ */
+ public void setEndpoint(Endpoint srvRef, String endpointName) {
+ this.endpoint = srvRef ;
+ this.endpointName = endpointName ;
+ }
+
+ /** Get the endpoint for the action (may be null) . */
+ public Endpoint getEndpoint() {
+ return endpoint ;
+ }
+
+ /**
+ * Returns whether or not the underlying DatasetGraph is fully transactional (supports rollback)
+ */
+ public boolean isTransactional() {
+ return isTransactional ;
+ }
+
+ public void beginRead() {
+ activeMode = READ ;
+ transactional.begin(READ) ;
+ activeDSG = dsg ;
+ dataService.startTxn(READ) ;
+ }
+
+ public void endRead() {
+ dataService.finishTxn(READ) ;
+ activeMode = null ;
+ transactional.end() ;
+ activeDSG = null ;
+ }
+
+ public void beginWrite() {
+ transactional.begin(WRITE) ;
+ activeMode = WRITE ;
+ activeDSG = dsg ;
+ dataService.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() {
+ dataService.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 void startRequest()
+ {
+ if ( dataAccessPoint != null )
+ dataAccessPoint.startRequest(this) ;
+ }
+
+ public final void finishRequest() {
+ if ( dataAccessPoint != null )
+ dataAccessPoint.finishRequest(this) ;
+ // Standard logging goes here.
+ if ( Fuseki.requestLog != null && Fuseki.requestLog.isInfoEnabled() ) {
+ String s = RequestLog.combinedNCSA(this) ;
+ Fuseki.requestLog.info(s);
+ }
+ }
+
+ /** If inside the transaction for the action, return the active {@link DatasetGraph},
+ * otherwise return null.
+ * @return Current active {@link DatasetGraph}
+ */
+ public final DatasetGraph getActiveDSG() {
+ return activeDSG ;
+ }
+
+ public final DataAccessPoint getDataAccessPoint() {
+ return dataAccessPoint;
+ }
+
+// public void setDataAccessPoint(DataAccessPoint dataAccessPoint) {
+// this.dataAccessPoint = dataAccessPoint;
+// }
+
+ public final DataService getDataService() {
+ return dataService;
+ }
+
+// public final void setDataService(DataService dataService) {
+// this.dataService = dataService;
+// }
+
+ public final String getDatasetName() {
+ return datasetName;
+ }
+
+// public void setDatasetName(String datasetName) {
+// this.datasetName = datasetName;
+// }
+
+ /** Reduce to a size that can be kept around for sometime.
+ * Release resources like datasets that may be closed, reset etc.
+ */
+ public void minimize() {
+ this.request = null ;
+ this.response = null ;
+ this.dsg = null ;
+ this.dataService = null ;
+ this.activeDSG = null ;
+ this.endpoint = null ;
+ }
+
+ public void setStartTime() {
+ if ( startTimeIsSet )
+ Log.warn(this, "Start time reset") ;
+ startTimeIsSet = true ;
+ this.startTime = System.nanoTime() ;
+ }
+
+ /** Start time, in system nanos */
+ public long getStartTime() {
+ if ( ! startTimeIsSet )
+ Log.warn(this, "Start time is not set") ;
+ return startTime ;
+ }
+
+ /** Start time, in system nanos */
+ public long getFinishTime() {
+ if ( ! finishTimeIsSet )
+ Log.warn(this, "Finish time is not set") ;
+ return finishTime ;
+ }
+
+ 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.
+ * {@link #setStartTime} and {@link #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) ;
+ }
+}
http://git-wip-us.apache.org/repos/asf/jena/blob/470ee4d7/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/HttpServletResponseTracker.java
----------------------------------------------------------------------
diff --git a/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/HttpServletResponseTracker.java b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/HttpServletResponseTracker.java
new file mode 100644
index 0000000..c39e728
--- /dev/null
+++ b/jena-fuseki2/jena-fuseki-core/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/470ee4d7/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/NullOutputStream.java
----------------------------------------------------------------------
diff --git a/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/NullOutputStream.java b/jena-fuseki2/jena-fuseki-core/src/main/java/org/apache/jena/fuseki/servlets/NullOutputStream.java
new file mode 100644
index 0000000..63e6562
--- /dev/null
+++ b/jena-fuseki2/jena-fuseki-core/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
+ }
+
+}