http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/conneg/WebLib.java ---------------------------------------------------------------------- diff --git a/jena-fuseki2/src/main/java/org/apache/jena/fuseki/conneg/WebLib.java b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/conneg/WebLib.java new file mode 100644 index 0000000..38dc265 --- /dev/null +++ b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/conneg/WebLib.java @@ -0,0 +1,60 @@ +/* + * 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.conneg; + +import java.util.Enumeration ; + +import javax.servlet.http.HttpServletRequest ; + +import org.apache.jena.riot.web.HttpNames ; + +public class WebLib +{ + /** Split a string, removing whitespace around the split string. + * e.g. Use in splitting HTTP accept/content-type headers. + */ + public static String[] split(String s, String splitStr) + { + String[] x = s.split(splitStr,2) ; + for ( int i = 0 ; i < x.length ; i++ ) + { + x[i] = x[i].trim() ; + } + return x ; + } + + /** Migrate to WebLib */ + public static String getAccept(HttpServletRequest httpRequest) + { + // There can be multiple accept headers -- note many tools don't allow these to be this way (e.g. wget, curl) + Enumeration<String> en = httpRequest.getHeaders(HttpNames.hAccept) ; + if ( ! en.hasMoreElements() ) + return null ; + StringBuilder sb = new StringBuilder() ; + String sep = "" ; + for ( ; en.hasMoreElements() ; ) + { + String x = en.nextElement() ; + sb.append(sep) ; + sep = ", " ; + sb.append(x) ; + } + return sb.toString() ; + } +}
http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/jetty/FusekiErrorHandler.java ---------------------------------------------------------------------- diff --git a/jena-fuseki2/src/main/java/org/apache/jena/fuseki/jetty/FusekiErrorHandler.java b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/jetty/FusekiErrorHandler.java new file mode 100644 index 0000000..40361de --- /dev/null +++ b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/jetty/FusekiErrorHandler.java @@ -0,0 +1,95 @@ +/* + * 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.jetty; + +import static java.lang.String.format ; + +import java.io.* ; + +import javax.servlet.http.HttpServletRequest ; +import javax.servlet.http.HttpServletResponse ; + +import org.apache.jena.atlas.io.IO ; +import org.apache.jena.fuseki.Fuseki ; +import org.apache.jena.fuseki.servlets.ServletOps ; +import org.apache.jena.web.HttpSC ; +import org.eclipse.jetty.http.HttpMethod ; +import org.eclipse.jetty.http.MimeTypes ; +import org.eclipse.jetty.server.Request ; +import org.eclipse.jetty.server.Response ; +import org.eclipse.jetty.server.handler.ErrorHandler ; + +public class FusekiErrorHandler extends ErrorHandler +{ + public FusekiErrorHandler() {} + + @Override + public void handle(String target, Request baseRequest, HttpServletRequest request, HttpServletResponse response) throws IOException + { + String method = request.getMethod(); + + if ( !method.equals(HttpMethod.GET.asString()) + && !method.equals(HttpMethod.POST.asString()) + && !method.equals(HttpMethod.HEAD.asString()) ) + return ; + + response.setContentType(MimeTypes.Type.TEXT_PLAIN_UTF_8.asString()) ; + ServletOps.setNoCache(response) ; + + ByteArrayOutputStream bytes = new ByteArrayOutputStream(1024) ; + try ( Writer writer = IO.asUTF8(bytes) ) { + String reason=(response instanceof Response)?((Response)response).getReason():null; + handleErrorPage(request, writer, response.getStatus(), reason) ; + + if ( ! Fuseki.VERSION.equalsIgnoreCase("development") && + ! Fuseki.VERSION.equals("${project.version}") ) + { + 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-fuseki2/src/main/java/org/apache/jena/fuseki/jetty/JettyFuseki.java ---------------------------------------------------------------------- diff --git a/jena-fuseki2/src/main/java/org/apache/jena/fuseki/jetty/JettyFuseki.java b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/jetty/JettyFuseki.java new file mode 100644 index 0000000..94c9f33 --- /dev/null +++ b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/jetty/JettyFuseki.java @@ -0,0 +1,267 @@ +/* + * 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.jetty ; + +import static java.lang.String.format ; +import static org.apache.jena.fuseki.Fuseki.serverLog ; + +import java.io.FileInputStream ; + +import org.apache.jena.atlas.lib.FileOps ; +import org.apache.jena.atlas.logging.LogCtl ; +import org.apache.jena.fuseki.Fuseki ; +import org.apache.jena.fuseki.FusekiException ; +import org.apache.jena.fuseki.mgt.MgtJMX ; +import org.eclipse.jetty.security.* ; +import org.eclipse.jetty.security.authentication.BasicAuthenticator ; +import org.eclipse.jetty.server.* ; +import org.eclipse.jetty.servlet.ServletContextHandler ; +import org.eclipse.jetty.util.security.Constraint ; +import org.eclipse.jetty.webapp.WebAppContext ; +import org.eclipse.jetty.xml.XmlConfiguration ; + +import com.hp.hpl.jena.sparql.util.Utils ; + +/** Standalone server, not run as a WAR file. + * Used in testing and development. + * + * 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.jetty.JettyServerConfig}. + */ +public class JettyFuseki { + // Jetty specific. + // This class is becoming less important - it now sets up a Jetty server for in-process use + // either for the command line in development + // and in testing but not direct webapp deployments. + static { Fuseki.init() ; } + + public static JettyFuseki instance = null ; + + private ServerConnector serverConnector = null ; + // If a separate ... + private ServerConnector mgtConnector = null ; + + private JettyServerConfig serverConfig ; + + // The jetty server. + private Server server = null ; + + // webapp setup - standard maven layout + public static String contextpath = "/" ; + public static final String resourceBase1 = "webapp" ; // Standalone jar + public static final String resourceBase2 = "src/main/webapp" ; // Development + + /** + * Default setup which requires a {@link org.apache.jena.fuseki.jetty.JettyServerConfig} + * object as input. We use this config to pass in the command line arguments for dataset, + * name etc. + * @param config + */ + + public static void initializeServer(JettyServerConfig config) { + // Currently server-wide. + Fuseki.verboseLogging = config.verboseLogging ; + instance = new JettyFuseki(config) ; + } + + /** Build a Jetty server using the development files for the webapp + * No command line configuration. + */ + public static Server create(int port) { + return create("/", port) ; + } + + public static Server create(String contextPath, int port) { + Server server = new Server(port) ; + WebAppContext webapp = createWebApp(contextPath) ; + server.setHandler(webapp) ; + return server ; + } + + private JettyFuseki(JettyServerConfig config) { + this.serverConfig = config ; + + buildServerWebapp(serverConfig.contextPath, serverConfig.jettyConfigFile, config.enableCompression) ; + + if ( mgtConnector == null ) + mgtConnector = serverConnector ; + } + + /** + * Initialize the {@link JettyFuseki} instance. + */ + public void start() { + + String version = Fuseki.VERSION ; + String buildDate = Fuseki.BUILD_DATE ; + + if ( version != null && version.equals("${project.version}") ) + version = null ; + if ( buildDate != null && buildDate.equals("${build.time.xsd}") ) + buildDate = Utils.nowAsXSDDateTimeString() ; + + if ( version != null && buildDate != null ) + serverLog.info(format("%s %s %s", Fuseki.NAME, version, buildDate)) ; + // 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 = serverConnector.getHost() ; + if ( host != null ) + serverLog.info("Incoming connections limited to " + host) ; + + try { + server.start() ; + } catch (java.net.BindException ex) { + serverLog.error("SPARQLServer (port="+serverConnector.getPort()+"): 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) ; + } + String now = Utils.nowAsString() ; + serverLog.info(format("Started %s on port %d", now, serverConnector.getPort())) ; + } + + /** + * Sync with the {@link JettyFuseki} instance. + * Returns only if the server exits cleanly + */ + public void join() { + try { + server.join() ; + } catch (InterruptedException ex) { } + } + + /** + * Stop the {@link JettyFuseki} instance. + */ + public void stop() { + String now = Utils.nowAsString() ; + serverLog.info(format("Stopped %s on port %d", now, serverConnector.getPort())) ; + try { + server.stop() ; + } catch (Exception ex) { + Fuseki.serverLog.warn("SPARQLServer: Exception while stopping server: " + ex.getMessage(), ex) ; + } + MgtJMX.removeJMX() ; + } + + public static WebAppContext createWebApp(String contextPath) { + WebAppContext webapp = new WebAppContext(); + webapp.getServletContext().getContextHandler().setMaxFormContentSize(10 * 1000 * 1000) ; + String resourceBase = null ; + if ( /*resourceBase == null &&*/ FileOps.exists(resourceBase1) ) + resourceBase = resourceBase1 ; + if ( resourceBase == null && FileOps.exists(resourceBase2) ) + resourceBase = resourceBase2 ; + if ( resourceBase == null ) + Fuseki.serverLog.warn("Can't find resourceBase (tried "+resourceBase1+" and "+resourceBase2+")") ; + + webapp.setDescriptor(resourceBase+"/WEB-INF/web.xml"); + webapp.setResourceBase(resourceBase); + webapp.setContextPath(contextPath); + + //-- Jetty setup for the ServletContext logger. + // The name of the Jetty-allocated slf4j/log4j logger is + // the display name or, if null, the context path name. + // It is set, without checking for a previous call of setLogger in "doStart" + // which happens during server startup. + // This the name of the ServletContext logger as well + webapp.setDisplayName(Fuseki.servletRequestLogName); + LogCtl.set(Fuseki.servletRequestLogName, "WARN"); + + webapp.setParentLoaderPriority(true); // Normal Java classloader behaviour. + webapp.setErrorHandler(new FusekiErrorHandler()) ; + return webapp ; + } + + private void buildServerWebapp(String contextPath, String jettyConfig, boolean enableCompression) { + if ( jettyConfig != null ) + // --jetty-config=jetty-fuseki.xml + // for detailed configuration of the server using Jetty features. + configServer(jettyConfig) ; + else + defaultServerConfig(serverConfig.port, serverConfig.loopback) ; + WebAppContext webapp = createWebApp(contextPath) ; + server.setHandler(webapp) ; + // Replaced by Shiro. + if ( jettyConfig == null && serverConfig.authConfigFile != null ) + security(webapp, serverConfig.authConfigFile) ; + } + + private static void security(ServletContextHandler context, String authfile) { + 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", authfile) ; + loginService.setIdentityService(identService) ; + + securityHandler.setLoginService(loginService) ; + securityHandler.setAuthenticator(new BasicAuthenticator()) ; + + context.setSecurityHandler(securityHandler) ; + + serverLog.debug("Basic Auth Configuration = " + authfile) ; + } + + private void configServer(String jettyConfig) { + try { + serverLog.info("Jetty server config file = " + jettyConfig) ; + server = new Server() ; + XmlConfiguration configuration = new XmlConfiguration(new FileInputStream(jettyConfig)) ; + configuration.configure(server) ; + serverConnector = (ServerConnector)server.getConnectors()[0] ; + } 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 void defaultServerConfig(int port, boolean loopback) { + server = new Server() ; + ConnectionFactory f1 = new HttpConnectionFactory() ; + ConnectionFactory f2 = new SslConnectionFactory() ; + + ServerConnector connector = new ServerConnector(server, f1) ; //, f2) ; + connector.setPort(port); + server.addConnector(connector); + + if ( loopback ) + connector.setHost("localhost"); + connector.setPort(port) ; + serverConnector = connector ; + } +} http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/jetty/JettyServerConfig.java ---------------------------------------------------------------------- diff --git a/jena-fuseki2/src/main/java/org/apache/jena/fuseki/jetty/JettyServerConfig.java b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/jetty/JettyServerConfig.java new file mode 100644 index 0000000..71012ef --- /dev/null +++ b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/jetty/JettyServerConfig.java @@ -0,0 +1,51 @@ +/** + * 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.jetty; + + +/** Configuration of the Jetty server when run from the command line directly, + * not as a webapp/war file. + */ + +public class JettyServerConfig +{ + public JettyServerConfig() {} + + /** Port to run the server service on */ + public int port ; + /** Port to run the server service on */ + public String contextPath ; + /** 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 ; + /** 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-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionAsyncTask.java ---------------------------------------------------------------------- diff --git a/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionAsyncTask.java b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionAsyncTask.java new file mode 100644 index 0000000..8d8a080 --- /dev/null +++ b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionAsyncTask.java @@ -0,0 +1,70 @@ +/** + * 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.mgt; + +import javax.servlet.http.HttpServletRequest ; +import javax.servlet.http.HttpServletResponse ; + +import org.apache.jena.atlas.json.JsonValue ; +import org.apache.jena.atlas.lib.InternalErrorException ; +import org.apache.jena.fuseki.async.AsyncPool ; +import org.apache.jena.fuseki.async.AsyncTask ; +import org.apache.jena.fuseki.servlets.HttpAction ; +import org.apache.jena.fuseki.servlets.ServletOps ; + +/** Base helper class for creating async tasks on "items", based on POST */ +public abstract class ActionAsyncTask extends ActionItem +{ + // ?? Better as a library (mixin) so can be used outside ActionItem + private static AsyncPool asyncPool = AsyncPool.get() ; + + public ActionAsyncTask() { super() ; } + + @Override + final + protected void doGet(HttpServletRequest request, HttpServletResponse response) { + ServletOps.errorMethodNotAllowed(METHOD_GET); + } + + @Override + final + protected JsonValue execGetItem(HttpAction action) { + throw new InternalErrorException("GET for AsyncTask -- Should not be here!") ; + } + + @Override + final + protected JsonValue execPostItem(HttpAction action) { + Runnable task = createRunnable(action) ; + AsyncTask aTask = Async.execASyncTask(action, AsyncPool.get(), "backup", task) ; + Async.setLocationHeader(action, aTask); + return Async.asJson(aTask) ; + } + + public static AsyncTask execASyncTask(HttpAction action, AsyncPool asyncPool, String displayName, Runnable task) { + AsyncTask atask = Async.asyncTask(asyncPool, displayName, action.getDataService(), task) ; + Async.setLocationHeader(action, atask); + JsonValue v = Async.asJson(atask) ; + ServletOps.sendJsonReponse(action, v); + return atask ; + } + + protected abstract Runnable createRunnable(HttpAction action) ; +} + http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionBackup.java ---------------------------------------------------------------------- diff --git a/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionBackup.java b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionBackup.java new file mode 100644 index 0000000..34f134e --- /dev/null +++ b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionBackup.java @@ -0,0 +1,84 @@ +/** + * 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.mgt; + +import static java.lang.String.format ; + +import javax.servlet.http.HttpServletRequest ; +import javax.servlet.http.HttpServletResponse ; + +import org.apache.jena.fuseki.servlets.HttpAction ; +import org.apache.jena.fuseki.servlets.ServletOps ; +import org.slf4j.Logger ; +import org.slf4j.LoggerFactory ; + +import com.hp.hpl.jena.sparql.core.DatasetGraph ; + +public class ActionBackup extends ActionAsyncTask +{ + public ActionBackup() { super() ; } + + // Only POST + @Override + protected void doPost(HttpServletRequest request, HttpServletResponse response) { + doCommon(request, response); + } + + @Override + protected Runnable createRunnable(HttpAction action) { + String name = action.getDatasetName() ; + if ( name == null ) { + action.log.error("Null for dataset name in item request") ; + ServletOps.errorOccurred("Null for dataset name in item request"); + return null ; + } + action.log.info(format("[%d] Backup dataset %s", action.id, name)) ; + return new BackupTask(action) ; + } + + static class BackupTask implements Runnable { + static private Logger log = LoggerFactory.getLogger("Backup") ; + + private final long actionId ; + private final DatasetGraph dataset ; + private final String datasetName ; + + public BackupTask(HttpAction action) { + this.actionId = action.id ; + action.getDataAccessPoint() ; + action.getDataAccessPoint().getDataService() ; + action.getDataAccessPoint().getDataService().getDataset() ; + this.dataset = action.getDataAccessPoint().getDataService().getDataset() ; + this.datasetName = action.getDatasetName() ; + } + + @Override + public void run() { + try { + String backupFilename = Backup.chooseFileName(datasetName) ; + log.info(format("[%d] >>>> Start backup %s -> %s", actionId, datasetName, backupFilename)) ; + Backup.backup(dataset, backupFilename) ; + log.info(format("[%d] <<<< Finish backup %s -> %s", actionId, datasetName, backupFilename)) ; + } catch (Exception ex) { + log.info(format("[%d] **** Exception in backup", actionId), ex) ; + } + } + } +} + \ No newline at end of file http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionContainerItem.java ---------------------------------------------------------------------- diff --git a/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionContainerItem.java b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionContainerItem.java new file mode 100644 index 0000000..134afc4 --- /dev/null +++ b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionContainerItem.java @@ -0,0 +1,94 @@ +/** + * 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.mgt; + +import org.apache.jena.atlas.json.JsonValue ; +import org.apache.jena.fuseki.servlets.HttpAction ; +import org.apache.jena.fuseki.servlets.ServletOps ; +import org.apache.jena.web.HttpSC ; + +/** Base for actions that are container and also have action on items */ +public abstract class ActionContainerItem extends ActionCtl { + + public ActionContainerItem() { super() ; } + + @Override + final + protected void perform(HttpAction action) { + String method = action.request.getMethod() ; + if ( method.equals(METHOD_GET) ) + execGet(action) ; + else if ( method.equals(METHOD_POST) ) + execPost(action) ; + else if ( method.equals(METHOD_DELETE) ) + execDelete(action) ; + else + ServletOps.error(HttpSC.METHOD_NOT_ALLOWED_405) ; + } + + protected void execGet(HttpAction action) { + JsonValue v ; + if ( isContainerAction(action) ) + v = execGetContainer(action) ; + else + v = execGetItem(action) ; + + ServletOps.sendJsonReponse(action, v); + } + + /** GET request on the container - respond with JSON, or null for plain 200 */ + protected abstract JsonValue execGetContainer(HttpAction action) ; + /** GET request on an item in the container - repond with JSON, or null for plain 200 */ + protected abstract JsonValue execGetItem(HttpAction action) ; + + protected void execPost(HttpAction action) { + JsonValue v ; + if ( isContainerAction(action) ) + v = execPostContainer(action) ; + else + v = execPostItem(action) ; + + ServletOps.sendJsonReponse(action, v); + } + + /** POST request on an item in the container - respond with JSON, or null for plain 200 */ + protected abstract JsonValue execPostContainer(HttpAction action) ; + /** POST request on an item in the container - respond with JSON, or null for plain 200 */ + protected abstract JsonValue execPostItem(HttpAction action) ; + + + /** DELETE request */ + protected void execDelete(HttpAction action) { + if ( isContainerAction(action) ) + execDeleteContainer(action) ; + else + execDeleteItem(action) ; + ServletOps.success(action) ; + } + + /** DELETE request on an item in the container */ + protected void execDeleteContainer(HttpAction action) { + ServletOps.errorMethodNotAllowed(METHOD_DELETE, "DELETE applied to a container") ; + } + + /** DELETE request on an item in the container */ + protected void execDeleteItem(HttpAction action) { + ServletOps.errorMethodNotAllowed(METHOD_DELETE) ; + } +} http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionCtl.java ---------------------------------------------------------------------- diff --git a/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionCtl.java b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionCtl.java new file mode 100644 index 0000000..20073d9 --- /dev/null +++ b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionCtl.java @@ -0,0 +1,97 @@ +/* + * 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.mgt; + +import org.apache.jena.fuseki.Fuseki ; +import org.apache.jena.fuseki.server.DataAccessPoint ; +import org.apache.jena.fuseki.server.DataAccessPointRegistry ; +import org.apache.jena.fuseki.server.DataService ; +import org.apache.jena.fuseki.servlets.ActionBase ; +import org.apache.jena.fuseki.servlets.HttpAction ; +import org.apache.jena.fuseki.servlets.ServletOps ; + +/** Control/admin request lifecycle */ +public abstract class ActionCtl extends ActionBase +{ + protected ActionCtl() { super(Fuseki.adminLog) ; } + + @Override + final + protected void execCommonWorker(HttpAction action) { + DataAccessPoint dataAccessPoint ; + DataService dSrv ; + + String datasetUri = mapRequestToDatasetName(action) ; + if ( datasetUri != null ) { + dataAccessPoint = DataAccessPointRegistry.get().get(datasetUri) ; + if ( dataAccessPoint == null ) { + ServletOps.errorNotFound("Not found: "+datasetUri) ; + return ; + } + } + else { + // This is a placeholder when creating new DatasetRefs + // and also if addressing a container, not a dataset + dataAccessPoint = null ; + dSrv = DataService.serviceOnlyDataService() ; + } + + action.setControlRequest(dataAccessPoint, datasetUri) ; + action.setEndpoint(null, null) ; // No operation or service name. + executeAction(action) ; + } + + protected String mapRequestToDatasetName(HttpAction action) { + return extractItemName(action) ; + } + + // Execute - no stats. + // Intercept point for the UberServlet + protected void executeAction(HttpAction action) { + executeLifecycle(action) ; + } + + // This is the service request lifecycle. + final + protected void executeLifecycle(HttpAction action) + { + startRequest(action) ; + try { + perform(action) ; + } + finally { + finishRequest(action) ; + } + } + + final + protected boolean isContainerAction(HttpAction action) { + return (action.getDataAccessPoint() == null ) ; + } + + protected abstract void perform(HttpAction action) ; + +// /** Map request to uri in the registry. +// * null means no mapping done (passthrough). +// */ +// protected String mapRequestToDataset(HttpAction action) +// { +// return ActionLib.mapRequestToDataset(action.request.getRequestURI()) ; +// } +} http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionDatasets.java ---------------------------------------------------------------------- diff --git a/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionDatasets.java b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionDatasets.java new file mode 100644 index 0000000..a623c28 --- /dev/null +++ b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionDatasets.java @@ -0,0 +1,400 @@ +/** + * 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.mgt; + +import static java.lang.String.format ; + +import java.io.* ; +import java.util.HashMap ; +import java.util.Iterator ; +import java.util.Map ; + +import javax.servlet.ServletException ; +import javax.servlet.ServletOutputStream ; +import javax.servlet.http.HttpServletRequest ; +import javax.servlet.http.HttpServletResponse ; + +import org.apache.jena.atlas.io.IO ; +import org.apache.jena.atlas.json.JsonBuilder ; +import org.apache.jena.atlas.json.JsonValue ; +import org.apache.jena.atlas.lib.InternalErrorException ; +import org.apache.jena.atlas.lib.StrUtils ; +import org.apache.jena.atlas.web.ContentType ; +import org.apache.jena.fuseki.FusekiLib ; +import org.apache.jena.fuseki.build.Builder ; +import org.apache.jena.fuseki.build.Template ; +import org.apache.jena.fuseki.build.TemplateFunctions ; +import org.apache.jena.fuseki.server.* ; +import org.apache.jena.fuseki.servlets.* ; +import org.apache.jena.riot.Lang ; +import org.apache.jena.riot.RDFDataMgr ; +import org.apache.jena.riot.RDFLanguages ; +import org.apache.jena.riot.WebContent ; +import org.apache.jena.riot.system.StreamRDF ; +import org.apache.jena.riot.system.StreamRDFLib ; +import org.apache.jena.web.HttpSC ; + +import com.hp.hpl.jena.datatypes.xsd.XSDDatatype ; +import com.hp.hpl.jena.graph.Node ; +import com.hp.hpl.jena.graph.NodeFactory ; +import com.hp.hpl.jena.query.Dataset ; +import com.hp.hpl.jena.query.ReadWrite ; +import com.hp.hpl.jena.rdf.model.* ; +import com.hp.hpl.jena.shared.uuid.JenaUUID ; +import com.hp.hpl.jena.sparql.core.DatasetGraph ; +import com.hp.hpl.jena.sparql.core.Quad ; +import com.hp.hpl.jena.sparql.util.FmtUtils ; +import com.hp.hpl.jena.tdb.transaction.DatasetGraphTransaction ; +import com.hp.hpl.jena.update.UpdateAction ; +import com.hp.hpl.jena.update.UpdateFactory ; +import com.hp.hpl.jena.update.UpdateRequest ; + +public class ActionDatasets extends ActionContainerItem { + + private static Dataset system = SystemState.getDataset() ; + private static DatasetGraphTransaction systemDSG = SystemState.getDatasetGraph() ; + + static private Property pServiceName = FusekiVocab.pServiceName ; + static private Property pStatus = FusekiVocab.pStatus ; + + private static final String paramDatasetName = "dbName" ; + private static final String paramDatasetType = "dbType" ; + private static final String tDatabasetTDB = "tdb" ; + private static final String tDatabasetMem = "mem" ; + + public ActionDatasets() { super() ; } + + @Override + protected void doGet(HttpServletRequest request, HttpServletResponse response) { + doCommon(request, response); + } + + @Override + protected void doPost(HttpServletRequest request, HttpServletResponse response) { + doCommon(request, response); + } + + @Override + protected void doDelete(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { + doCommon(request, response); + } + + // ---- GET : return details of dataset or datasets. + @Override + protected JsonValue execGetContainer(HttpAction action) { + action.log.info(format("[%d] GET datasets", action.id)) ; + JsonBuilder builder = new JsonBuilder() ; + builder.startObject("D") ; + builder.key(JsonConst.datasets) ; + JsonDescription.arrayDatasets(builder, DataAccessPointRegistry.get()); + builder.finishObject("D") ; + return builder.build() ; + } + + @Override + protected JsonValue execGetItem(HttpAction action) { + action.log.info(format("[%d] GET dataset %s", action.id, action.getDatasetName())) ; + JsonBuilder builder = new JsonBuilder() ; + DataAccessPoint dsDesc = DataAccessPointRegistry.get().get(action.getDatasetName()) ; + if ( dsDesc == null ) + ServletOps.errorNotFound("Not found: dataset "+action.getDatasetName()); + JsonDescription.describe(builder, dsDesc) ; + return builder.build() ; + } + + // ---- POST + + @Override + protected JsonValue execPostContainer(HttpAction action) { + JenaUUID uuid = JenaUUID.generate() ; + String newURI = uuid.asURI() ; + Node gn = NodeFactory.createURI(newURI) ; + + ContentType ct = FusekiLib.getContentType(action) ; + + boolean committed = false ; + system.begin(ReadWrite.WRITE) ; + try { + Model model = system.getNamedModel(gn.getURI()) ; + StreamRDF dest = StreamRDFLib.graph(model.getGraph()) ; + + if ( WebContent.isHtmlForm(ct) ) + assemblerFromForm(action, dest) ; + else if ( WebContent.isMultiPartForm(ct) ) + assemblerFromUpload(action, dest) ; + else + assemblerFromBody(action, dest) ; + + // Keep a persistent copy. + String filename = FusekiServer.dirFileArea.resolve(uuid.asString()).toString() ; + try ( OutputStream outCopy = new FileOutputStream(filename) ) { + RDFDataMgr.write(outCopy, model, Lang.TURTLE) ; + } + + Statement stmt = getOne(model, null, pServiceName, null) ; + if ( stmt == null ) { + StmtIterator sIter = model.listStatements(null, pServiceName, (RDFNode)null ) ; + if ( ! sIter.hasNext() ) + ServletOps.errorBadRequest("No name given in description of Fuseki service") ; + sIter.next() ; + if ( sIter.hasNext() ) + ServletOps.errorBadRequest("Multiple names given in description of Fuseki service") ; + throw new InternalErrorException("Inconsistent: getOne didn't fail the second time") ; + } + + if ( ! stmt.getObject().isLiteral() ) + ServletOps.errorBadRequest("Found "+FmtUtils.stringForRDFNode(stmt.getObject())+" : Service names are strings, then used to build the external URI") ; + + Resource subject = stmt.getSubject() ; + Literal object = stmt.getObject().asLiteral() ; + + if ( object.getDatatype() != null && ! object.getDatatype().equals(XSDDatatype.XSDstring) ) + action.log.warn(format("[%d] Service name '%s' is not a string", action.id, FmtUtils.stringForRDFNode(object))); + + String datasetName = object.getLexicalForm() ; + String datasetPath = DataAccessPoint.canonical(datasetName) ; + action.log.info(format("[%d] Create database : name = %s", action.id, datasetPath)) ; + + if ( DataAccessPointRegistry.get().isRegistered(datasetPath) ) + // And abort. + ServletOps.error(HttpSC.CONFLICT_409, "Name already registered "+datasetPath) ; + + model.removeAll(null, pStatus, null) ; + model.add(subject, pStatus, FusekiVocab.stateActive) ; + + // Need to be in Resource space at this point. + DataAccessPoint ref = Builder.buildDataAccessPoint(subject) ; + DataAccessPointRegistry.register(datasetPath, ref) ; + action.getResponse().setContentType(WebContent.contentTypeTextPlain); + ServletOutputStream out = action.getResponse().getOutputStream() ; + out.println("That went well") ; + ServletOps.success(action) ; + system.commit(); + committed = true ; + + } catch (IOException ex) { IO.exception(ex); } + finally { + if ( ! committed ) system.abort() ; + system.end() ; + } + return null ; + } + + @Override + protected JsonValue execPostItem(HttpAction action) { + String name = action.getDatasetName() ; + if ( name == null ) + name = "''" ; + action.log.info(format("[%d] POST dataset %s", action.id, name)) ; + + if ( action.getDataAccessPoint() == null ) + ServletOps.errorNotFound("Not found: dataset "+action.getDatasetName()); + + DataService dSrv = action.getDataService() ; + if ( dSrv == null ) + // If not set explicitly, take from DataAccessPoint + dSrv = action.getDataAccessPoint().getDataService() ; + + String s = action.request.getParameter("state") ; + if ( s == null || s.isEmpty() ) + ServletOps.errorBadRequest("No state change given") ; + + // setDatasetState is a transaction on the persistent state of the server. + if ( s.equalsIgnoreCase("active") ) { + action.log.info(format("[%d] REBUILD DATASET %s", action.id, name)) ; + setDatasetState(name, FusekiVocab.stateActive) ; + dSrv.goActive() ; + // DatasetGraph dsg = ???? ; + //dSrv.activate(dsg) ; + //dSrv.activate() ; + } else if ( s.equalsIgnoreCase("offline") ) { + action.log.info(format("[%d] OFFLINE DATASET %s", action.id, name)) ; + DataAccessPoint access = action.getDataAccessPoint() ; + //access.goOffline() ; + dSrv.goOffline() ; // Affects the target of the name. + setDatasetState(name, FusekiVocab.stateOffline) ; + //dSrv.offline() ; + } else if ( s.equalsIgnoreCase("unlink") ) { + action.log.info(format("[%d] UNLINK ACCESS NAME %s", action.id, name)) ; + DataAccessPoint access = action.getDataAccessPoint() ; + ServletOps.errorNotImplemented("unlink: dataset"+action.getDatasetName()); + //access.goOffline() ; + // Registry? + } + else + ServletOps.errorBadRequest("State change operation '"+s+"' not recognized"); + return null ; + } + + private void assemblerFromBody(HttpAction action, StreamRDF dest) { + bodyAsGraph(action, dest) ; + } + + private void assemblerFromForm(HttpAction action, StreamRDF dest) { + String dbType = action.getRequest().getParameter(paramDatasetType) ; + String dbName = action.getRequest().getParameter(paramDatasetName) ; + Map<String, String> params = new HashMap<>() ; + params.put(Template.NAME, dbName) ; + FusekiServer.addGlobals(params); + + action.log.info(format("[%d] Create database : name = %s, type = %s", action.id, dbName, dbType )) ; + if ( dbType == null || dbName == null ) + ServletOps.errorBadRequest("Required parameters: dbName and dbType"); + if ( ! dbType.equals(tDatabasetTDB) && ! dbType.equals(tDatabasetMem) ) + ServletOps.errorBadRequest(format("dbType can be only '%s' or '%s'", tDatabasetTDB, tDatabasetMem)) ; + + String template = null ; + if ( dbType.equalsIgnoreCase(tDatabasetTDB)) + template = TemplateFunctions.templateFile(Template.templateTDBFN, params) ; + if ( dbType.equalsIgnoreCase(tDatabasetMem)) + template = TemplateFunctions.templateFile(Template.templateMemFN, params) ; + RDFDataMgr.parse(dest, new StringReader(template), "http://base/";, Lang.TTL) ; + } + + private void assemblerFromUpload(HttpAction action, StreamRDF dest) { + Upload.fileUploadWorker(action, dest); + } + + // ---- DELETE + + @Override + protected void execDeleteItem(HttpAction action) { +// if ( isContainerAction(action) ) { +// ServletOps.errorBadRequest("DELETE only applies to a specific dataset.") ; +// return ; +// } + + // Does not exist? + String name = action.getDatasetName() ; + if ( name == null ) + name = "" ; + action.log.info(format("[%d] DELETE ds=%s", action.id, name)) ; + + if ( ! DataAccessPointRegistry.get().isRegistered(name) ) + ServletOps.errorNotFound("No such dataset registered: "+name); + + systemDSG.begin(ReadWrite.WRITE) ; + boolean committed = false ; + try { + // Here, go offline. + // Need to reference count operations when they drop to zero + // or a timer goes off, we delete the dataset. + + DataAccessPoint ref = DataAccessPointRegistry.get().get(name) ; + // Redo check inside transaction. + if ( ref == null ) + ServletOps.errorNotFound("No such dataset registered: "+name); + + // Name to graph + Quad q = getOne(SystemState.getDatasetGraph(), null, null, pServiceName.asNode(), null) ; + if ( q == null ) + ServletOps.errorBadRequest("Failed to find dataset for '"+name+"'"); + Node gn = q.getGraph() ; + + action.log.info("SHUTDOWN NEEDED"); + DataAccessPointRegistry.get().remove(name) ; + systemDSG.deleteAny(gn, null, null, null) ; + systemDSG.commit() ; + committed = true ; + ServletOps.success(action) ; + } finally { + if ( ! committed ) systemDSG.abort() ; + systemDSG.end() ; + } + } + + // Persistent state change. + private void setDatasetState(String name, Resource newState) { + boolean committed = false ; + system.begin(ReadWrite.WRITE) ; + try { + String dbName = name ; + if ( dbName.startsWith("/") ) + dbName = dbName.substring(1) ; + + String update = StrUtils.strjoinNL + (SystemState.PREFIXES, + "DELETE { GRAPH ?g { ?s fu:status ?state } }", + "INSERT { GRAPH ?g { ?s fu:status "+FmtUtils.stringForRDFNode(newState)+" } }", + "WHERE {", + " GRAPH ?g { ?s fu:name '"+dbName+"' ; ", + " fu:status ?state .", + " }", + "}" + ) ; + UpdateRequest req = UpdateFactory.create(update) ; + UpdateAction.execute(req, system); + system.commit(); + committed = true ; + } finally { + if ( ! committed ) system.abort() ; + system.end() ; + } + } + + // ---- Auxilary functions + + private static Quad getOne(DatasetGraph dsg, Node g, Node s, Node p, Node o) { + Iterator<Quad> iter = dsg.findNG(g, s, p, o) ; + if ( ! iter.hasNext() ) + return null ; + Quad q = iter.next() ; + if ( iter.hasNext() ) + return null ; + return q ; + } + + private static Statement getOne(Model m, Resource s, Property p, RDFNode o) { + StmtIterator iter = m.listStatements(s, p, o) ; + if ( ! iter.hasNext() ) + return null ; + Statement stmt = iter.next() ; + if ( iter.hasNext() ) + return null ; + return stmt ; + } + + // XXX Merge with Upload.incomingData + + private static void bodyAsGraph(HttpAction action, StreamRDF dest) { + HttpServletRequest request = action.request ; + String base = ActionLib.wholeRequestURL(request) ; + ContentType ct = FusekiLib.getContentType(request) ; + Lang lang = RDFLanguages.contentTypeToLang(ct.getContentType()) ; + if ( lang == null ) { + ServletOps.errorBadRequest("Unknown content type for triples: " + ct) ; + return ; + } + InputStream input = null ; + try { input = request.getInputStream() ; } + catch (IOException ex) { IO.exception(ex) ; } + + int len = request.getContentLength() ; +// if ( verbose ) { +// if ( len >= 0 ) +// alog.info(format("[%d] Body: Content-Length=%d, Content-Type=%s, Charset=%s => %s", action.id, len, +// ct.getContentType(), ct.getCharset(), lang.getName())) ; +// else +// alog.info(format("[%d] Body: Content-Type=%s, Charset=%s => %s", action.id, ct.getContentType(), +// ct.getCharset(), lang.getName())) ; +// } + dest.prefix("root", base+"#"); + ActionSPARQL.parse(action, dest, input, lang, base) ; + } +} http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionItem.java ---------------------------------------------------------------------- diff --git a/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionItem.java b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionItem.java new file mode 100644 index 0000000..72d3c65 --- /dev/null +++ b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionItem.java @@ -0,0 +1,45 @@ +/** + * 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.mgt; + +import org.apache.jena.atlas.json.JsonValue ; +import org.apache.jena.fuseki.servlets.HttpAction ; +import org.apache.jena.fuseki.servlets.ServletOps ; +import org.apache.jena.web.HttpSC ; + +/** Action on items in a container, but not the container itself */ +public abstract class ActionItem extends ActionContainerItem +{ + public ActionItem() { super() ; } + + @Override + final + protected JsonValue execGetContainer(HttpAction action) { + ServletOps.error(HttpSC.METHOD_NOT_ALLOWED_405) ; + return null ; + } + + @Override + final + protected JsonValue execPostContainer(HttpAction action) { + ServletOps.error(HttpSC.METHOD_NOT_ALLOWED_405) ; + return null ; + } +} + http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionLogs.java ---------------------------------------------------------------------- diff --git a/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionLogs.java b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionLogs.java new file mode 100644 index 0000000..c4d6579 --- /dev/null +++ b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionLogs.java @@ -0,0 +1,59 @@ +/** + * 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.mgt; + +import static org.apache.jena.riot.WebContent.charsetUTF8 ; +import static org.apache.jena.riot.WebContent.contentTypeTextPlain ; + +import java.io.IOException ; + +import javax.servlet.ServletOutputStream ; +import javax.servlet.http.HttpServletRequest ; +import javax.servlet.http.HttpServletResponse ; + +import org.apache.jena.fuseki.servlets.HttpAction ; +import org.apache.jena.fuseki.servlets.ServletOps ; + +public class ActionLogs extends ActionCtl +{ + public ActionLogs() { super() ; } + + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) { + doCommon(req, resp); + } + + @Override + protected void perform(HttpAction action) { + execGet(action) ; + } + + protected void execGet(HttpAction action) { + try { + HttpServletResponse response = action.response ; + ServletOutputStream out = response.getOutputStream() ; + response.setContentType(contentTypeTextPlain) ; + response.setCharacterEncoding(charsetUTF8) ; + out.println("Not implemented yet") ; + out.println() ; + out.flush() ; + ServletOps.success(action); + } catch (IOException ex) { ServletOps.errorOccurred(ex) ; } + } +} http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionPing.java ---------------------------------------------------------------------- diff --git a/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionPing.java b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionPing.java new file mode 100644 index 0000000..2426af6 --- /dev/null +++ b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionPing.java @@ -0,0 +1,71 @@ +/** + * 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.mgt; + +import static org.apache.jena.riot.WebContent.charsetUTF8 ; +import static org.apache.jena.riot.WebContent.contentTypeTextPlain ; + +import java.io.IOException ; + +import javax.servlet.ServletOutputStream ; +import javax.servlet.http.HttpServlet ; +import javax.servlet.http.HttpServletRequest ; +import javax.servlet.http.HttpServletResponse ; + +import org.apache.jena.fuseki.Fuseki ; +import org.apache.jena.fuseki.servlets.ServletOps ; +import org.apache.jena.web.HttpSC ; + +public class ActionPing extends HttpServlet +{ + // Ping is special. + // To avoid excessive logging and id allocation for a "noise" operation, + // this is a raw servlet. + public ActionPing() { super() ; } + + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) { + doCommon(req, resp); + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) { + doCommon(req, resp); + } + + + @Override + protected void doHead(HttpServletRequest req, HttpServletResponse resp) { + doCommon(req, resp); + } + + protected void doCommon(HttpServletRequest request, HttpServletResponse response) { + try { + ServletOps.setNoCache(response) ; + ServletOutputStream out = response.getOutputStream() ; + response.setContentType(contentTypeTextPlain); + response.setCharacterEncoding(charsetUTF8) ; + response.setStatus(HttpSC.OK_200); + } catch (IOException ex) { + Fuseki.serverLog.warn("ping :: IOException :: "+ex.getMessage()); + } + } +} + + http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionServerStatus.java ---------------------------------------------------------------------- diff --git a/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionServerStatus.java b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionServerStatus.java new file mode 100644 index 0000000..d8f5b1e --- /dev/null +++ b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionServerStatus.java @@ -0,0 +1,114 @@ +/** + * 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.mgt; + +import static org.apache.jena.riot.WebContent.charsetUTF8 ; +import static org.apache.jena.riot.WebContent.contentTypeJSON ; + +import java.io.IOException ; + +import javax.servlet.ServletOutputStream ; +import javax.servlet.http.HttpServletRequest ; +import javax.servlet.http.HttpServletResponse ; + +import org.apache.jena.atlas.json.JSON ; +import org.apache.jena.atlas.json.JsonBuilder ; +import org.apache.jena.atlas.json.JsonValue ; +import org.apache.jena.fuseki.Fuseki ; +import org.apache.jena.fuseki.server.DataAccessPointRegistry ; +import org.apache.jena.fuseki.servlets.HttpAction ; +import org.apache.jena.fuseki.servlets.ServletOps ; + +/** Description of datasets for a server */ +public class ActionServerStatus extends ActionCtl +{ + public ActionServerStatus() { super() ; } + + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) { + doCommon(req, resp) ; + } + + @Override + protected void doPost(HttpServletRequest req, HttpServletResponse resp) { + doCommon(req, resp) ; + } + + @Override + protected void perform(HttpAction action) { + try { + description(action) ; + ServletOps.success(action) ; + } catch (IOException e) { + ServletOps.errorOccurred(e) ; + } + } + + private void description(HttpAction action) throws IOException { + ServletOutputStream out = action.response.getOutputStream() ; + action.response.setContentType(contentTypeJSON); + action.response.setCharacterEncoding(charsetUTF8) ; + + JsonBuilder builder = new JsonBuilder() ; + builder.startObject() ; + describeServer(builder, action.request.getLocalPort()) ; + describeDatasets(builder) ; + builder.finishObject() ; + + JsonValue v = builder.build() ; + JSON.write(out, v) ; + out.println() ; + out.flush() ; + } + + private void describeServer(JsonBuilder builder, int requestPort) { + String versionStr = Fuseki.VERSION ; + String builtDateStr = Fuseki.BUILD_DATE ; + if ( versionStr == null || versionStr.startsWith("${") ) + versionStr = "Development" ; + if ( builtDateStr == null || builtDateStr.startsWith("${") ) + builtDateStr = "Unknown" ; + +// builder +// .key(JsonConst.server) +// .startObject() +// .key(JsonConst.port).value(port) +// .finishObject() ; + builder + .key(JsonConst.admin) + .startObject() + .key(JsonConst.port).value(requestPort) + .finishObject() ; + + builder + .key(JsonConst.version).value(versionStr) + .key(JsonConst.built).value(builtDateStr) + .key(JsonConst.startDT).value(Fuseki.serverStartedAt()) + .key(JsonConst.uptime).value(Fuseki.serverUptimeSeconds()) + ; + + } + + private void describeDatasets(JsonBuilder builder) { + builder.key(JsonConst.datasets) ; + JsonDescription.arrayDatasets(builder, DataAccessPointRegistry.get()); + } + +} + http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionSleep.java ---------------------------------------------------------------------- diff --git a/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionSleep.java b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionSleep.java new file mode 100644 index 0000000..e53eb9a --- /dev/null +++ b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionSleep.java @@ -0,0 +1,98 @@ +/** + * 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.mgt; + +import static java.lang.String.format ; + +import javax.servlet.http.HttpServletRequest ; +import javax.servlet.http.HttpServletResponse ; + +import org.apache.jena.atlas.json.JsonValue ; +import org.apache.jena.atlas.lib.Lib ; +import org.apache.jena.fuseki.async.AsyncPool ; +import org.apache.jena.fuseki.async.AsyncTask ; +import org.apache.jena.fuseki.servlets.HttpAction ; +import org.apache.jena.fuseki.servlets.ServletOps ; +import org.slf4j.Logger ; + +/** A task that kicks off a asynchornous operation that simply waits and exits. For testing. */ +public class ActionSleep extends ActionCtl /* Not ActionAsyncTask - that is a container */ +{ + public ActionSleep() { super() ; } + + // And only POST + @Override + protected void doPost(HttpServletRequest request, HttpServletResponse response) { + doCommon(request, response); + } + + @Override + protected void perform(HttpAction action) { + Runnable task = createRunnable(action) ; + AsyncTask aTask = Async.execASyncTask(action, AsyncPool.get(), "sleep", task) ; + JsonValue v = Async.asJson(aTask) ; + Async.setLocationHeader(action, aTask); + ServletOps.sendJsonReponse(action, v); + } + + protected Runnable createRunnable(HttpAction action) { + String name = action.getDatasetName() ; + if ( name == null ) { +// action.log.error("Null for dataset name in item request") ; +// ServletOps.errorOccurred("Null for dataset name in item request"); +// return null ; + name = "''" ; + } + + String interval = action.request.getParameter("interval") ; + int sleepMilli = 5000 ; + if ( interval != null ) + try { + sleepMilli = Integer.parseInt(interval) ; + } catch (NumberFormatException ex) { + action.log.error(format("[%d] NumberFormatException: %s", action.id, interval)) ; + } + action.log.info(format("[%d] Sleep %s %d ms", action.id, name, sleepMilli)) ; + return new SleepTask(action, sleepMilli) ; + } + + static class SleepTask implements Runnable { + private final Logger log ; + private final long actionId ; + private final int sleepMilli ; + + public SleepTask(HttpAction action, int sleepMilli ) { + this.log = action.log ; + this.actionId = action.id ; + this.sleepMilli = sleepMilli ; + } + + @Override + public void run() { + try { + log.info(format("[%d] >> Sleep start", actionId)) ; + Lib.sleep(sleepMilli) ; + log.info(format("[%d] << Sleep finish", actionId)) ; + } catch (Exception ex) { + log.info(format("[%d] **** Exception", actionId), ex) ; + } + } + } +} + http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionStats.java ---------------------------------------------------------------------- diff --git a/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionStats.java b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionStats.java new file mode 100644 index 0000000..490bce2 --- /dev/null +++ b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionStats.java @@ -0,0 +1,214 @@ +/** + * 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.mgt; + +import static java.lang.String.format ; +import static org.apache.jena.riot.WebContent.charsetUTF8 ; +import static org.apache.jena.riot.WebContent.contentTypeTextPlain ; + +import java.io.IOException ; +import java.util.Iterator ; +import java.util.List ; + +import javax.servlet.ServletOutputStream ; +import javax.servlet.http.HttpServletRequest ; +import javax.servlet.http.HttpServletResponse ; + +import org.apache.jena.atlas.json.JsonBuilder ; +import org.apache.jena.atlas.json.JsonValue ; +import org.apache.jena.fuseki.server.* ; +import org.apache.jena.fuseki.servlets.HttpAction ; + +public class ActionStats extends ActionContainerItem +{ + // XXX Use ActionContainerItem + public ActionStats() { super() ; } + + @Override + protected void doGet(HttpServletRequest req, HttpServletResponse resp) { + doCommon(req, resp); + } + + // This does not consult the system database for dormant etc. + @Override + protected JsonValue execGetContainer(HttpAction action) { + action.log.info(format("[%d] GET stats all", action.id)) ; + JsonBuilder builder = new JsonBuilder() ; + builder.startObject("top") ; + + builder.key(JsonConst.datasets) ; + builder.startObject("datasets") ; + for ( String ds : DataAccessPointRegistry.get().keys() ) + statsDataset(builder, ds) ; + builder.finishObject("datasets") ; + + builder.finishObject("top") ; + return builder.build() ; + } + + @Override + protected JsonValue execGetItem(HttpAction action) { + action.log.info(format("[%d] GET stats dataset %s", action.id, action.getDatasetName())) ; + + JsonBuilder builder = new JsonBuilder() ; + String datasetPath = DataAccessPoint.canonical(action.getDatasetName()) ; + builder.startObject("TOP") ; + + builder.key(JsonConst.datasets) ; + builder.startObject("datasets") ; + statsDataset(builder, datasetPath) ; + builder.finishObject("datasets") ; + + builder.finishObject("TOP") ; + return builder.build() ; + } + + private void statsDataset(JsonBuilder builder, String ds) { + // Object started + builder.key(ds) ; + + DataAccessPoint access = DataAccessPointRegistry.get().get(ds) ; + DataService dSrv = access.getDataService() ; + builder.startObject("counters") ; + + builder.key(CounterName.Requests.name()).value(dSrv.getCounters().value(CounterName.Requests)) ; + builder.key(CounterName.RequestsGood.name()).value(dSrv.getCounters().value(CounterName.RequestsGood)) ; + builder.key(CounterName.RequestsBad.name()).value(dSrv.getCounters().value(CounterName.RequestsBad)) ; + + + // Build the operation -> endpoint list map. + +// MultiMap<OperationName, Endpoint> map = MultiMap.createMapList() ; +// for ( OperationName operName : dSrv.getOperations() ) { +// List<Endpoint> endpoints = access.getDataService().getOperation(operName) ; +// for ( Endpoint endpoint : endpoints ) +// map.put(operName, endpoint) ; +// } + + + builder.key(JsonConst.endpoints).startObject("endpoints") ; + + for ( OperationName operName : dSrv.getOperations() ) { + List<Endpoint> endpoints = access.getDataService().getOperation(operName) ; +// System.err.println(operName+" : "+endpoints.size()) ; +// for ( Endpoint endpoint : endpoints ) +// System.err.println(" "+endpoint.getEndpoint()) ; + + for ( Endpoint endpoint : endpoints ) { + + // Endpoint names are unique but not services. + + builder.key(endpoint.getEndpoint()) ; + builder.startObject() ; + + operationCounters(builder, endpoint); + builder.key(JsonConst.operation).value(operName.name()) ; + builder.key(JsonConst.description).value(operName.getDescription()) ; + + builder.finishObject() ; + } + } + builder.finishObject("endpoints") ; + builder.finishObject("counters") ; + + } + + private void operationCounters(JsonBuilder builder, Endpoint operation) { + for (CounterName cn : operation.getCounters().counters()) { + Counter c = operation.getCounters().get(cn) ; + builder.key(cn.name()).value(c.value()) ; + } + } + + private void statsTxt(HttpServletResponse resp) throws IOException + { + ServletOutputStream out = resp.getOutputStream() ; + resp.setContentType(contentTypeTextPlain); + resp.setCharacterEncoding(charsetUTF8) ; + + Iterator<String> iter = DataAccessPointRegistry.get().keys().iterator() ; + while(iter.hasNext()) + { + String ds = iter.next() ; + DataAccessPoint desc = DataAccessPointRegistry.get().get(ds) ; + statsTxt(out, desc) ; + if ( iter.hasNext() ) + out.println() ; + } + out.flush() ; + } + + private void statsTxt(ServletOutputStream out, DataAccessPoint desc) throws IOException + { + DataService dSrv = desc.getDataService() ; + out.println("Dataset: "+desc.getName()) ; + out.println(" Requests = "+dSrv.getCounters().value(CounterName.Requests)) ; + out.println(" Good = "+dSrv.getCounters().value(CounterName.RequestsGood)) ; + out.println(" Bad = "+dSrv.getCounters().value(CounterName.RequestsBad)) ; + + out.println(" SPARQL Query:") ; + out.println(" Request = "+counter(dSrv, OperationName.Query, CounterName.Requests)) ; + out.println(" Good = "+counter(dSrv, OperationName.Query, CounterName.RequestsGood)) ; + out.println(" Bad requests = "+counter(dSrv, OperationName.Query, CounterName.RequestsBad)) ; + out.println(" Timeouts = "+counter(dSrv, OperationName.Query, CounterName.QueryTimeouts)) ; + out.println(" Bad exec = "+counter(dSrv, OperationName.Query, CounterName.QueryExecErrors)) ; + out.println(" IO Errors = "+counter(dSrv, OperationName.Query, CounterName.QueryIOErrors)) ; + + out.println(" SPARQL Update:") ; + out.println(" Request = "+counter(dSrv, OperationName.Update, CounterName.Requests)) ; + out.println(" Good = "+counter(dSrv, OperationName.Update, CounterName.RequestsGood)) ; + out.println(" Bad requests = "+counter(dSrv, OperationName.Update, CounterName.RequestsBad)) ; + out.println(" Bad exec = "+counter(dSrv, OperationName.Update, CounterName.UpdateExecErrors)) ; + + out.println(" Upload:") ; + out.println(" Requests = "+counter(dSrv, OperationName.Upload, CounterName.Requests)) ; + out.println(" Good = "+counter(dSrv, OperationName.Upload, CounterName.RequestsGood)) ; + out.println(" Bad = "+counter(dSrv, OperationName.Upload, CounterName.RequestsBad)) ; + + out.println(" SPARQL Graph Store Protocol:") ; + out.println(" GETs = "+gspValue(dSrv, CounterName.HTTPget)+ " (good="+gspValue(dSrv, CounterName.HTTPgetGood)+"/bad="+gspValue(dSrv, CounterName.HTTPGetBad)+")") ; + out.println(" PUTs = "+gspValue(dSrv, CounterName.HTTPput)+ " (good="+gspValue(dSrv, CounterName.HTTPputGood)+"/bad="+gspValue(dSrv, CounterName.HTTPputBad)+")") ; + out.println(" POSTs = "+gspValue(dSrv, CounterName.HTTPpost)+ " (good="+gspValue(dSrv, CounterName.HTTPpostGood)+"/bad="+gspValue(dSrv, CounterName.HTTPpostBad)+")") ; + out.println(" DELETEs = "+gspValue(dSrv, CounterName.HTTPdelete)+ " (good="+gspValue(dSrv, CounterName.HTTPdeleteGood)+"/bad="+gspValue(dSrv, CounterName.HTTPdeleteBad)+")") ; + out.println(" HEADs = "+gspValue(dSrv, CounterName.HTTPhead)+ " (good="+gspValue(dSrv, CounterName.HTTPheadGood)+"/bad="+gspValue(dSrv, CounterName.HTTPheadBad)+")") ; + } + + private long counter(DataService dSrv, OperationName opName, CounterName cName) { + return 0 ; + } + + private long gspValue(DataService dSrv, CounterName cn) { + return counter(dSrv, OperationName.GSP, cn) + + counter(dSrv, OperationName.GSP_R, cn) ; + } + + // We shouldn't get here - no doPost above. + + @Override + protected JsonValue execPostContainer(HttpAction action) { + throw new InternalError(METHOD_POST+" container") ; + } + + @Override + protected JsonValue execPostItem(HttpAction action) { + throw new InternalError(METHOD_POST+" item") ; + } +} + + http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionTasks.java ---------------------------------------------------------------------- diff --git a/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionTasks.java b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionTasks.java new file mode 100644 index 0000000..97f8027 --- /dev/null +++ b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/ActionTasks.java @@ -0,0 +1,125 @@ +/** + * 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.mgt; +import static java.lang.String.format ; + +import javax.servlet.http.HttpServletRequest ; +import javax.servlet.http.HttpServletResponse ; + +import org.apache.jena.atlas.json.JsonBuilder ; +import org.apache.jena.atlas.json.JsonValue ; +import org.apache.jena.fuseki.Fuseki ; +import org.apache.jena.fuseki.async.AsyncPool ; +import org.apache.jena.fuseki.async.AsyncTask ; +import org.apache.jena.fuseki.servlets.ActionBase ; +import org.apache.jena.fuseki.servlets.HttpAction ; +import org.apache.jena.fuseki.servlets.ServletOps ; +import org.apache.jena.web.HttpSC ; + +public class ActionTasks extends ActionBase //ActionContainerItem +{ + private static AsyncPool[] pools = { AsyncPool.get() } ; + + public ActionTasks() { super(Fuseki.serverLog) ; } + + @Override + protected void doGet(HttpServletRequest request, HttpServletResponse response) { + doCommon(request, response); + } + + @Override + protected void doPost(HttpServletRequest request, HttpServletResponse response) { + doCommon(request, response); + } + + private static String prefix = "/" ; + + @Override + protected void execCommonWorker(HttpAction action) { + String name = extractItemName(action) ; + if ( name != null ) { + if ( name.startsWith(prefix)) + name = name.substring(prefix.length()) ; + else + log.warn("Unexpected task name : "+name) ; + } + + String method = action.request.getMethod() ; + if ( method.equals(METHOD_GET) ) + execGet(action, name) ; + else if ( method.equals(METHOD_POST) ) + execPost(action, name) ; + else + ServletOps.error(HttpSC.METHOD_NOT_ALLOWED_405) ; + } + + private void execGet(HttpAction action, String name) { + if ( name == null ) + log.info(format("[%d] Tasks", action.id)); + else + log.info(format("[%d] Task %s", action.id, name)); + + JsonValue responseBody = null ; + + if ( name == null ) { + JsonBuilder builder = new JsonBuilder() ; + builder.startArray() ; + + for ( AsyncPool pool : pools ) { + for ( AsyncTask aTask : pool.tasks() ) { + //builder.value(aTask.getTaskId()) ; + descOneTask(builder, aTask) ; + } + } + builder.finishArray() ; + responseBody = builder.build(); + } else { + for ( AsyncPool pool : pools ) { + // Assumes first is only. + AsyncTask aTask = pool.getTask(name) ; + if ( aTask != null ) { + JsonBuilder builder = new JsonBuilder() ; + descOneTask(builder, aTask); + responseBody = builder.build() ; + } + } + } + + if ( responseBody == null ) + ServletOps.errorNotFound("Task '"+name+"' not found") ; + ServletOps.setNoCache(action) ; + ServletOps.sendJsonReponse(action, responseBody); + } + + private void execPost(HttpAction action, String name) { + + } + + private static void descOneTask(JsonBuilder builder, AsyncTask aTask) { + builder.startObject("SingleTask") ; + builder.key(JsonConst.task).value(aTask.displayName()) ; + builder.key(JsonConst.taskId).value(aTask.getTaskId()) ; + if ( aTask.getStartPoint() != null ) + builder.key(JsonConst.started).value(aTask.getStartPoint()) ; + if ( aTask.getFinishPoint() != null ) + builder.key(JsonConst.finished).value(aTask.getFinishPoint()) ; + builder.finishObject("SingleTask") ; + } +} + http://git-wip-us.apache.org/repos/asf/jena/blob/36855e1b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/Async.java ---------------------------------------------------------------------- diff --git a/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/Async.java b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/Async.java new file mode 100644 index 0000000..1cbda48 --- /dev/null +++ b/jena-fuseki2/src/main/java/org/apache/jena/fuseki/mgt/Async.java @@ -0,0 +1,68 @@ +/** + * 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.mgt; + +import org.apache.http.HttpHeaders ; +import org.apache.jena.atlas.json.JsonBuilder ; +import org.apache.jena.atlas.json.JsonValue ; +import org.apache.jena.fuseki.async.AsyncPool ; +import org.apache.jena.fuseki.async.AsyncTask ; +import org.apache.jena.fuseki.server.DataService ; +import org.apache.jena.fuseki.servlets.HttpAction ; + +public class Async +{ + public static AsyncTask asyncTask(AsyncPool asyncPool, String displayName, DataService dataService, Runnable task) { + AsyncTask asyncTask = asyncPool.submit(task, displayName, dataService) ; + return asyncTask ; + } + + public static JsonValue asJson(AsyncTask asyncTask) { + JsonBuilder builder = new JsonBuilder() ; + builder.startObject("outer") ; + builder.key(JsonConst.taskId).value(asyncTask.getTaskId()) ; + builder.finishObject("outer") ; + return builder.build() ; + } + + public static void setLocationHeader(HttpAction action, AsyncTask asyncTask) { + String x = action.getRequest().getRequestURI() ; + if ( ! x.endsWith("/") ) + x += "/" ; + x += asyncTask.getTaskId() ; + //String x = "/$/tasks/"+asyncTask.getTaskId() ; + action.getResponse().setHeader(HttpHeaders.LOCATION, x) ; + } + + public static AsyncTask execASyncTask(HttpAction action, AsyncPool asyncPool, String displayName, Runnable runnable) { + AsyncTask atask = Async.asyncTask(asyncPool, "backup", action.getDataService(), runnable) ; + Async.setLocationHeader(action, atask); + return atask ; + } + + // Combined does not work very well - e.g sleep does not set Location. +// public static AsyncTask execASyncTask(HttpAction action, AsyncPool asyncPool, String displayName, Runnable task) { +// AsyncTask atask = Async.asyncTask(asyncPool, displayName, action.getDataService(), task) ; +// Async.setLocationHeader(action, atask); +// JsonValue v = Async.asJson(atask) ; +// ServletOps.sendJsonReponse(action, v); +// return atask ; +// } +} +
