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 2020/09/20 15:38:55 UTC
[jena-site] 01/01: Fuseki doc updates
This is an automated email from the ASF dual-hosted git repository.
andy pushed a commit to branch fuseki-config
in repository https://gitbox.apache.org/repos/asf/jena-site.git
commit 88d48b018614b8033d4c609503d0f80ba78e7e28
Author: Andy Seaborne <an...@apache.org>
AuthorDate: Sat Sep 19 11:47:36 2020 +0100
Fuseki doc updates
---
source/documentation/fuseki2/__index.md | 61 +++---
.../fuseki2/fuseki-config-endpoint.md | 158 ++++++++------
.../documentation/fuseki2/fuseki-configuration.md | 226 +++++++++++++--------
...ss-control.md => fuseki-data-access-control.md} | 75 ++++---
.../documentation/fuseki2/fuseki-data-services.md | 2 +-
source/documentation/fuseki2/fuseki-docker.md | 112 ++++++++++
.../fuseki2/{fuseki-main.md => fuseki-embedded.md} | 62 +-----
source/documentation/fuseki2/fuseki-logging.md | 18 +-
source/documentation/fuseki2/fuseki-main.md | 211 +++----------------
.../fuseki2/fuseki-old-config-endpoint.md | 55 +++++
source/documentation/fuseki2/fuseki-quick-start.md | 2 +-
source/documentation/fuseki2/fuseki-security.md | 5 +-
source/documentation/fuseki2/fuseki-server-info.md | 116 +++++++++++
.../fuseki2/fuseki-server-protocol.md | 2 +-
source/documentation/fuseki2/fuseki-stats.md | 115 -----------
.../fuseki2/{fuseki-run.md => fuseki-webapp.md} | 79 ++++---
16 files changed, 682 insertions(+), 617 deletions(-)
diff --git a/source/documentation/fuseki2/__index.md b/source/documentation/fuseki2/__index.md
index 447a77f..5a6d4d8 100644
--- a/source/documentation/fuseki2/__index.md
+++ b/source/documentation/fuseki2/__index.md
@@ -5,36 +5,39 @@ slug: index
Apache Jena Fuseki is a SPARQL server. It can run as a operating system
service, as a Java web application (WAR file), and as a standalone server.
-It provides security (using [Apache Shiro](https://shiro.apache.org/)) and
-has a user interface for server monitoring and administration.
-It provides the SPARQL 1.1
-[protocols for query and update](http://www.w3.org/TR/sparql11-protocol/)
+Fuseki comes in in two forms, a single system "webapp", combined with a UI
+for admin and query, and as "main", a server suitable to run as part of a larger
+deployment, including [with Docker](fuseki-main.html#docker) or running embedded.
+Both forms use the same core protocol engine and [same configuration file
+format](fuseki-configuration.html).
+
+Fuseki provides the
+SPARQL 1.1 [protocols for query and update](http://www.w3.org/TR/sparql11-protocol/)
as well as the
[SPARQL Graph Store protocol](http://www.w3.org/TR/sparql11-http-rdf-update/).
Fuseki is tightly integrated with [TDB](../tdb/index.html) to provide a robust,
transactional persistent storage layer, and incorporates
[Jena text query](../query/text-query.html).
-It can be used to provide the protocol engine for other RDF query and
-storage systems.
## Contents
-- [Download](#download-fuseki)
+- [Download with UI](#download-fuseki)
- [Getting Started](#getting-started-with-fuseki)
-- [Security](fuseki-security.html)
-- [Running Fuseki](fuseki-run.html)
- - [As a standalone server with UI](fuseki-run.html#fuseki-standalone-server)
- - [As a service](fuseki-run.html#fuseki-service)
- - [As a web application](fuseki-run.html#fuseki-web-application)
- - [As an standalone SPARQL server](fuseki-main.html)
- - [As an embedded SPARQL server](fuseki-main.html)
-- Architecture
- - [Server URI scheme : services and datasets](fuseki-data-services.html)
- - [Server Admin Protocol](fuseki-server-protocol.html)
+- [Running Fuseki with UI](fuseki-webapp.html)
+ - [As a standalone server with UI](fuseki-webapp.html#fuseki-standalone-server)
+ - [As a service](fuseki-webapp.html#fuseki-service)
+ - [As a web application](fuseki-webapp.html#fuseki-web-application)
+ - [Security](fuseki-security.html) with [Apache Shiro](https://shiro.apache.org/)
+- [Running Fuseki Server](fuseki-main.html)
+ - [Setup](fuseki-main.html#setup)
+ - [As a Docker container](fuseki-main#fuseki-docker)
+ - [As an embedded SPARQL server](fuseki-embedded.html)
+ - [Security and data access control](fuseki-data-access-control.html)
- [Fuseki Configuration](fuseki-configuration.html)
- [Logging](fuseki-logging.html)
+- [Server Statistics and Metrics](fuseki-server-info.html)
- [How to Contribute](#how-to-contribute)
- Client access
- [Use from Java](../rdfconnection)
@@ -45,7 +48,7 @@ The Jena users mailing is the place to get help with Fuseki.
[Email support lists](/help_and_support/#email-support-lists)
-## Download Fuseki
+## Download Fuseki with UI
Releases of Apache Jena Fuseki can be downloaded from one of the mirror sites:
@@ -57,20 +60,14 @@ preference to any older versions.
**Fuseki download files**
-Filename | Description
---------- | -----------
-`fuseki-*VER*.distribution.zip` | Fuseki download, includes everything.
-`fuseki-*VER*-server.jar` | Fuseki server, as an executable jar.
-`fuseki-*VER*-server.war` | Fuseki server, as a web application archive (.war) file.
+| Filename | Description |
+|---------|-------------|
+|`apache-jena-fuseki-*VER*.zip` | Fuseki with UI download |
+|`[jena-fuseki-server](https://repo1.maven.org/maven2/org/apache/jena/jena-fuseki-server) | The Fuseki Main packaging |
- <dependency>
- <groupId>org.apache.jena</groupId>
- <artifactId>jena-fuseki-war</artifactId>
- <type>war</type>
- <version>X.Y.Z</version>
- </dependency>
+`apache-jena-fuseki-*VER*.zip` contains both a war file and an executable jar.
-and for [Fuseki Main](fuseki-main):
+Fuskei Main is also available as a Maven artifact:
<dependency>
<groupId>org.apache.jena</groupId>
@@ -99,7 +96,7 @@ This includes packaged builds of Fuseki.
The [quick start](fuseki-quick-start.html) section serves as a basic
guide to getting a Fuseki server running on your local machine.
-See [all the ways to run Fuseki](fuseki-run.html) for complete coverage of all the
+See [all the ways to run Fuseki](fuseki-webapp.html) for complete coverage of all the
deployment methods for Fuseki.
## How to Contribute
@@ -119,5 +116,5 @@ The development codebase is available from git.
Development builds (not a formal release):
[SNAPSHOT](https://repository.apache.org/content/repositories/snapshots/org/apache/jena/jena-fuseki/)
-Source code mirrored to github:
+Source code:
[https://github.com/apache/jena/tree/master/jena-fuseki2](https://github.com/apache/jena/tree/master/jena-fuseki2)
diff --git a/source/documentation/fuseki2/fuseki-config-endpoint.md b/source/documentation/fuseki2/fuseki-config-endpoint.md
index 45512a2..2914959 100644
--- a/source/documentation/fuseki2/fuseki-config-endpoint.md
+++ b/source/documentation/fuseki2/fuseki-config-endpoint.md
@@ -1,17 +1,8 @@
---
-title: Fuseki Configuration - New Syntax
+title: Fuseki Data Service Configuration Syntax
---
-Apache Jena 3.13.0 introduces a new syntax for the facilities of a Fuseki service.
-
-The [previous syntax](fuseki-configuration.html) is still valid.
-
-The new syntax enables more configuration options:
-
-* setting the context on a per-endpoint basis
-* having multiple operations at the service access point, switching based on
-operation type
-* a more general structure for adding custom services
+Data service provide a number of operations on a dataset. These can be explicitly named endpoints or operations at he URL of the dataset. New operations can be configured in; these typically have their own named endpoints.
## Syntax
@@ -35,16 +26,13 @@ query, and then only on the dataset URL.
ja:data "data.trig" .
This is invoked with a URL of the form
-<tt>http://<i>host:port</i>/dataset?query=...</tt>
-which is a SPARQl query request sent to the dataset URL.
-
-The new syntax is the `fuseki:endpoint`.
+<tt>http://<i>host:port</i>/dataset?query=.\..</tt>
+which is a SPARQL query request sent to the dataset URL.
The property `fuseki:endpoint` describes the operation available. No name is
given so the operation is available at the URL of the dataset.
-`fuseki:dataset` names the dataset to be used with this data service. The syntax
-and options are unchanged from the [previous syntax](fuseki-configuration.html).
+`fuseki:dataset` names the dataset to be used with this data service.
In this second example:
@@ -58,7 +46,7 @@ In this second example:
the endpoint has a name. The URL to invoke the operation is now:
-<tt>http://<i>host:port</i>/dataset/sparql?query=...</tt>
+<tt>http://<i>host:port</i>/dataset/sparql?query=.\..</tt>
and is similar to older form:
@@ -78,40 +66,24 @@ the default. The first example is the same as:
] ;
fuseki:dataset <#dataset> .
+### Original Configuration Syntax
-The standard set of service installed by running the server from the command line
-without a configuration file is:
+The syntax described on this page was introduced in Apache Jena 3.13.0.
- <#service1> rdf:type fuseki:Service ;
- fuseki:name "dataset" ;
- fuseki:endpoint [
- fuseki:operation fuseki:query ;
- fuseki:name "sparql"
- ];
- fuseki:endpoint [
- fuseki:operation fuseki:query ;
- fuseki:name "query"
- ] ;
- fuseki:endpoint [
- fuseki:operation fuseki:update ;
- fuseki:name "update"
- ] ;
- fuseki:endpoint [
- fuseki:operation fuseki:gsp-r ;
- fuseki:name "get"
- ] ;
- fuseki:endpoint [
- fuseki:operation fuseki:gsp-rw ;
- fuseki:name "data"
- ] ;
- fuseki:endpoint [
- fuseki:operation fuseki:upload ;
- fuseki:name "upload"
- ] ;
- fuseki:dataset ...
+The [previous syntax](fuseki-old-config-endpoint.html) is still valid.
+
+The new syntax enables more configuration options and gives more control of server functionality:
+
+* setting the context on a per-endpoint basis
+* having multiple operations at the service access point, switching based on
+operation type
+* a more general structure for adding custom services
+* adding custom extensions to a Fuseki server
## Operations
+The following operations are provided:
+
| URI | Operation |
|-----|-----------|
| `fuseki:query` | SPARQL 1.1 Query with ARQ extensions |
@@ -121,6 +93,61 @@ without a configuration file is:
| `fuseki:upload` | HTML form file upload |
| `fuseki:no-op` | An operation that causes a 400 or 404 error |
+Custom extensions can be added (see [Programmatic configuration](fuseki-main.html#build) of the Fuseki server). To be able to uniquely identify the operation, these are usually
+
+ fuseki:endpoint [
+ fuseki:operation fuseki:shacl ;
+ fuseki:name "shacl" ;
+ ] ;
+
+See the section ["Integration with Apache Jena Fuseki"](https://jena.apache.org/documentation/shacl/#integration-with-apache-jena-fuseki) for details of the SHACL support. While this operation is part of the standard Fuseki distribution, this operation is added during system initialization, using the custom operation support.
+
+### Command Line Equivalents
+
+The standard set of service installed by running the server from the command line
+without a configuration file is for a read-only:
+
+ <#service1> rdf:type fuseki:Service ;
+ fuseki:name "dataset" ;
+ fuseki:endpoint [ fuseki:operation fuseki:query ; ];
+ fuseki:endpoint [ fuseki:operation fuseki:query ; fuseki:name "sparql" ];
+ fuseki:endpoint [ fuseki:operation fuseki:query ; fuseki:name "query" ];
+
+ fuseki:endpoint [ fuseki:operation fuseki:gsp-r ; ];
+ fuseki:endpoint [ fuseki:operation fuseki:gsp-r ; fuseki:name "get" ];
+ fuseki:dataset ...
+
+which supports requests such as:
+
+ http://<i>host:port</i>/dataset?query=...
+
+ http://<i>host:port</i>/dataset/sparql?query=...
+
+ http://<i>host:port</i>/dataset?default
+
+ http://<i>host:port</i>/dataset/get?default
+
+and for an updateatable dataset (command line `--mem` for an in-memory dataset;
+or with TDB storage, with `--update`):
+
+ <#service1> rdf:type fuseki:Service ;
+ fuseki:name "dataset" ;
+ fuseki:endpoint [ fuseki:operation fuseki:query ;];
+ fuseki:endpoint [ fuseki:operation fuseki:query ; fuseki:name "sparql" ];
+ fuseki:endpoint [ fuseki:operation fuseki:query ; fuseki:name "query" ];
+
+ fuseki:endpoint [ fuseki:operation fuseki:update ; ];
+ fuseki:endpoint [ fuseki:operation fuseki:update ; fuseki:name "update" ];
+
+ fuseki:endpoint [ fuseki:operation fuseki:gsp-r ; fuseki:name "get" ];
+ fuseki:endpoint [ fuseki:operation fuseki:gsp-rw ; ] ;
+ fuseki:endpoint [ fuseki:operation fuseki:gsp-rw ; fuseki:name "data" ];
+ fuseki:endpoint [ fuseki:operation fuseki:upload ; fuseki:name "upload" ]
+ fuseki:dataset ...
+
+which add requests that can change the data.
+
+
New operations can be added by programmatic setup in [Fuseki Main](/documentation/fuseki2/fuseki-main).
## Dispatch
@@ -146,13 +173,15 @@ A GSP operation has `?default` or `?graph=`.
Quads operations have no query string and a have a `Content-Type` for a data in
a RDF triples or quads syntax.
+Quads operations only apply to requests sen tot he dataset URL.
+
So, for example "GET /dataset" is a request to get all the triples and quads in the
dataset. The syntax for the response is determined by content negotiation,
defaulting to `text/trig`.
Custom services usually use a named endpoint. Custom operations
can specific a content type that they handle, which must be unique for the
-operation, and they can not provide a query string signature for dispatch.
+operation. They can not provide a query string signature for dispatch.
## Common Cases
@@ -173,7 +202,7 @@ This is good for publishing data.
#### Case 2: Dataset level operation.
-The 3 SPARQL standard operations for a read-write dataset:
+The 3 SPARQL standard operations for a read-write dataset, request are sent to <tt>http://<i>host:port</i>/dataset</tt>. There are no named endpoint services.
<#service> rdf:type fuseki:Service ;
fuseki:name "ds-rw" ;
@@ -198,6 +227,23 @@ The 3 SPARQL standard operations for a read-write dataset:
The operation on this dataset can only be accessed as "/ds-named/sparql",
"/ds-named/update" etc, not as "/ds-named".
+#### Case 4: Named endpoints with query of the dataset.
+
+ <#service1> rdf:type fuseki:Service ;
+
+ fuseki:name "ds" ;
+ fuseki:endpoint [ fuseki:operation fuseki:query ] ;
+ fuseki:endpoint [ fuseki:operation fuseki:query; fuseki:name "sparql" ] ;
+ fuseki:endpoint [ fuseki:operation fuseki:query; fuseki:name "query" ] ;
+ fuseki:endpoint [ fuseki:operation fuseki:update; fuseki:name "update" ] ;
+ fuseki:endpoint [ fuseki:operation fuseki:upload; fuseki:name "upload" ] ;
+ fuseki:endpoint [ fuseki:operation fuseki:gsp_r; fuseki:name "get" ] ;
+ fuseki:endpoint [ fuseki:operation fuseki:gsp_rw; fuseki:name "data" ] ;
+ fuseki:dataset <#dataset> .
+
+The operations on this dataset are accessed as "/ds/sparql",
+"/ds/update" etc. In addition, "/ds?query=" provided SPARQL query.
+
## Quad extensions
The GSP (SPARQL Graph Store Protocol) operations provide the HTTP operations of
@@ -213,7 +259,8 @@ and the request or response is one of the syntaxes for datasets
Fuseki also provides [/documentation/io/rdf-binary.html](RDF Binary) for triples and quads.
-The quads extension applies when there is no `?default` or `?graph`.
+The quads extension applies when there is no `?default` or `?graph`.
+`GET` fetches the dataset in quads format, and `PUT` and `POST` take quads format data (N-Quads and Trig).
## Context
@@ -253,7 +300,7 @@ seconds, and complete results in 30 seconds.
## Security
-The page [Data Access Control for Fuseki](/documentation/fuseki2/data-access-control)
+The page [Data Access Control for Fuseki](./fuseki-data-access-control.html)
covers the
For endpoints, the permitted users are part of the endpoint description.
@@ -263,12 +310,3 @@ For endpoints, the permitted users are part of the endpoint description.
fuseki:name "sparql" ;
fuseki:allowedUsers "user1", "user2"
] ;
-
-## Legacy Behaviour
-
-For compatibility with the older configuration behaviour, the Fuseki dispatch
-code includes an additional dispatch option.
-
-If a request is made on the dataset (no service name in the request URL), then
-the dispatcher classifies the operation and looks for a named endpoint for that
-operation of any name. If one is found, that is used.
diff --git a/source/documentation/fuseki2/fuseki-configuration.md b/source/documentation/fuseki2/fuseki-configuration.md
index 38fed78..c973c82 100644
--- a/source/documentation/fuseki2/fuseki-configuration.md
+++ b/source/documentation/fuseki2/fuseki-configuration.md
@@ -2,22 +2,38 @@
title: "Fuseki: Configuring Fuseki"
---
-Configuration consists of defining the data services (data and actions available on the data) together with configuring the server. Explicitly configuring the server is often unnecessary.
+A Fuseki server is configured by defining the data services (data and actions available on the data). There is also server configuration although this is often unnecessary.
The data services configuration can come from:
+For Fuseki Full (webapp with UI):
+
1. The directory `FUSEKI_BASE/configuration/` with one data service assembler per file (includes endpoint details and the dataset description.)
2. The system database. This includes uploaded assembler files. It also keeps the state of each data service (whether it's active or offline).
-3. The service configuration file. For compatibility, the service configuration file can also have data services. [See below](#relationship-to-fuseki-1-configuration).
+3. The server configuration file `config.ttl`. For compatibility, the server configuration file can also have data services.
4. The command line, if not running as a web application from a .war file.
`FUSEKI_BASE` is the location of the [Fuseki run area](./fuseki-layout.html).
-## Data Service assembler
+For [Fuseki Main](fuseki-main.html):
+
+1. The command line, using `--conf` to provide a configuration file.
+2. The command line, using arguments (e.g. `--mem /ds` or `--tdb2 --loc DB2 /ds`).
+3. [Programmatic configuration](fuseki-main.html#build) of the server.
+
+See [Fuseki Security](fuseki-security.html) for more information on security configuration.
+
+## Examples
+
+Example server configuration files can be found at [jena-fuseki2/examples](https://github.com/apache/jena/tree/master/jena-fuseki2/examples).
-See [Fuseki Data Services](fuseki-data-services.html) for the architecture of data services.
+## Security and Access Control
-See [Fuseki Security](fuseki-security.html) for more information on security.
+Access Control can be configured on any of the server, data service or dataset.
+[Fuseki Data Access Control](fuseki-data-access-control.html).
+
+Separately, Fuseki Full has request based security filtering provided by Apache Shiro:
+[Fuseki Full Security](fuseki-security.html)
## Fuseki Configuration File
@@ -37,12 +53,13 @@ split to allow for commentary.
Some useful prefix declarations:
- @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 ja: <http://jena.hpl.hp.com/2005/11/Assembler#> .
- @prefix : <#> .
+ 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 tdb1: <http://jena.hpl.hp.com/2008/tdb#>
+ PREFIX tdb2: <http://jena.apache.org/2016/tdb#>
+ PREFIX ja: <http://jena.hpl.hp.com/2005/11/Assembler#>
+ PREFIX : <#>
### Assembler Initialization
@@ -62,46 +79,126 @@ Each data service assembler defines:
This example offers SPARQL Query, SPARQL Update and SPARQL Graph
Store protocol, as well as file upload.
-Note: As of Jena 3.13.0,
-[an additional, more expressive configuration for endpoints](fuseki-config-endpoint.html)
-is available.
+See [Data Service Configuration Syntax](fuseki-config-endpoint.html) for the complete details of the endpoint configuration description. Here, we show some examples.
+
+The [original configuration](fuseki-old-config-endpoint.html) syntax, using, for example, `fuseki:serviceQuery`, is still supported.
The base name is `/ds`.
- ## Updateable in-memory dataset.
+ ## Updatable in-memory dataset.
<#service1> rdf:type fuseki:Service ;
- fuseki:name "ds" ; # http://host:port/ds
- fuseki:serviceQuery "sparql" ; # SPARQL query service
- fuseki:serviceQuery "query" ; # SPARQL query service (alt name)
- fuseki:serviceUpdate "update" ; # SPARQL update service
- fuseki:serviceUpload "upload" ; # Non-SPARQL upload service
- fuseki:serviceReadWriteGraphStore "data" ; # SPARQL Graph store protocol (read and write)
- # A separate read-only graph store endpoint:
- fuseki:serviceReadGraphStore "get" ; # SPARQL Graph store protocol (read only)
- fuseki:dataset <#dataset> ;
+ fuseki:name "ds" ; # http://host:port/ds
+ fuseki:endpoint [
+ # SPARQL query service
+ fuseki:operation fuseki:query ;
+ fuseki:name "sparql"
+ ] ;
+ fuseki:endpoint [
+ # SPARQL query service (alt name)
+ fuseki:operation fuseki:query ;
+ fuseki:name "query"
+ ] ;
+
+ fuseki:endpoint [
+ # SPARQL update service
+ fuseki:operation fuseki:update ;
+ fuseki:name "update"
+ ] ;
+
+ fuseki:endpoint [
+ # HTML file upload service
+ fuseki:operation fuseki:update ;
+ fuseki:name "update"
+ ] ;
+
+ fuseki:endpoint [
+ # SPARQL Graph Store Protocol (read)
+ fuseki:operation fuseki:gsp_r ;
+ fuseki:name "get"
+ ] ;
+ fuseki:endpoint [
+ # SPARQL Graph Store Protcol (read and write)
+ fuseki:operation fuseki:gsp_rw ;
+ fuseki:name "data"
+ ] ;
+
+ fuseki:dataset <#dataset> ;
.
`<#dataset>` refers to a dataset description in the same file.
+HTTP requests will include the service name: <tt>http://<i>host:port</i>/ds/sparql?query=.\..</tt>.
+
### Read-only service
This example offers only read-only endpoints (SPARQL Query and HTTP GET
-SPARQl Graph Store protocol).
+SPARQL Graph Store protocol).
This service offers read-only access to a dataset with a single
graph of data.
<#service2> rdf:type fuseki:Service ;
- fuseki:name "/ds-ro" ; # http://host:port/ds-ro
- fuseki:serviceQuery "query" ; # SPARQL query service
- fuseki:serviceReadGraphStore "data" ; # SPARQL Graph store protocol (read only)
+ fuseki:name "/ds-ro" ; # http://host:port/ds-ro
+ fuseki:endpoint [ fuseki:operation fuseki:query ; fuseki:name "sparql" ];
+ fuseki:endpoint [ fuseki:operation fuseki:query ; fuseki:name "query" ];
+ fuseki:endpoint [ fuseki:operation fuseki:gsp_r ; fuseki:name "data" ];
fuseki:dataset <#dataset> ;
.
-### Dataset
+### Data services on the dataset
+
+The standard SPARQL operations can also be defined on the dataset URL with no secondary service name:
+
+<#service2> rdf:type fuseki:Service ;
+ fuseki:name "/dataset" ;
+ fuseki:endpoint [ fuseki:operation fuseki:query ];
+ fuseki:endpoint [ fuseki:operation fuseki:gsp_r ];
+ fuseki:dataset <#dataset> ;
+ .
+
+HTTP requests use the URL of the dataset.
+
+* SPARQL Query: <tt>http://<i>host:port</i>/dataset?query=.\..</tt>
+* Fetch the default graph
+([SPARQL Graph Store Protocol](https://www.w3.org/TR/sparql11-http-rdf-update/)):
+<tt>http://<i>host:port</i>/dataset?default</tt>
+
+## Server Configuration
+
+If you need to load additional classes, or set global parameters, then these go in
+`FUSEKI_BASE/config.ttl`.
+
+Additional classes can not be loaded if running as a `.war` file. You will
+need to create a custom `.war` file consisting of the contents of the Fuseki
+web application and the additional classes
-#### In-memory
+The server section is optional.
+
+If absent, fuseki configuration is performed
+by searching the configuration file for the type `fuseki:Service`.
+
+### Server Section
+
+ [] rdf:type fuseki:Server ;
+ # Server-wide context parameters can be given here.
+ # For example, to set query timeouts: on a server-wide basis:
+ # Format 1: "1000" -- 1 second timeout
+ # Format 2: "10000,60000" -- 10s timeout to first result, then 60s timeout to for rest of query.
+ # See java doc for ARQ.queryTimeout
+ # ja:context [ ja:cxtName "arq:queryTimeout" ; ja:cxtValue "10000" ] ;
+
+ # Load custom code (rarely needed)
+ # ja:loadClass "your.code.Class" ;
+
+ # Explicitly choose which services to add to the server.
+ # If absent, include all descriptions of type `fuseki:Service`.
+ # fuseki:services (<#service1> <#service2>)
+ .
+
+## Datasets
+
+### In-memory
An in-memory dataset, with data in the default graph taken from a local file.
@@ -114,7 +211,7 @@ An in-memory dataset, with data in the default graph taken from a local file.
] ;
.
-#### TDB
+### TDB
<#dataset> rdf:type tdb:DatasetTDB ;
tdb:location "DB" ;
@@ -124,7 +221,7 @@ An in-memory dataset, with data in the default graph taken from a local file.
## tdb:unionDefaultGraph true ;
.
-#### TDB2
+### TDB2
<#dataset> rdf:type tdb:DatasetTDB2 ;
tdb:location "DB2" ;
@@ -134,7 +231,7 @@ An in-memory dataset, with data in the default graph taken from a local file.
## tdb:unionDefaultGraph true ;
.
-#### Inference
+### Inference
An inference reasoner can be layered on top of a dataset as defined above. The type of reasoner must be selected carefully and should not include more reasoning than is required by the application, as extensive reasoning can be detrimental to performance.
@@ -155,7 +252,7 @@ You have to build up layers of dataset, inference model, and graph.
where `http://example/someReasonerURLHere` is one of the URLs below.
-##### Possible reasoners:
+#### Possible reasoners:
Details are in [the main documentation for inference](/documentation/inference/).
@@ -171,59 +268,28 @@ Details are in [the main documentation for inference](/documentation/inference/)
The triples in the tbox (if present) will also be included in any query. Any of tbox or data graph are allowed to be null.
- * **RDFS Rule Reasoner**: `http://jena.hpl.hp.com/2003/RDFSExptRuleReasoner`
+ **RDFS Rule Reasoner**: `http://jena.hpl.hp.com/2003/RDFSExptRuleReasoner`
A full implementation of RDFS reasoning using a hybrid rule system, together with optimized subclass/subproperty closure using the transitive graph caches. Implements the container membership property rules using an optional data scanning hook. Implements datatype range validation.
- * **Full OWL Reasoner**: `http://jena.hpl.hp.com/2003/OWLFBRuleReasoner`
-
+* **Full OWL Reasoner**: `http://jena.hpl.hp.com/2003/OWLFBRuleReasoner`
+
A hybrid forward/backward implementation of the OWL closure rules.
- * **Mini OWL Reasoner**: `http://jena.hpl.hp.com/2003/OWLMiniFBRuleReasoner`
-
+* **Mini OWL Reasoner**: `http://jena.hpl.hp.com/2003/OWLMiniFBRuleReasoner`
+
Key limitations over the normal OWL configuration are:
- * omits the someValuesFrom => bNode entailments
- * avoids any guard clauses which would break the find() contract
- * omits inheritance of range implications for XSD datatype ranges
+ * omits the someValuesFrom => bNode entailments
+ * avoids any guard clauses which would break the find() contract
+ * omits inheritance of range implications for XSD datatype ranges
- * **Micro OWL Reasoner**: `http://jena.hpl.hp.com/2003/OWLMicroFBRuleReasoner`
+* **Micro OWL Reasoner**: `http://jena.hpl.hp.com/2003/OWLMicroFBRuleReasoner`
- This only supports:
- * RDFS entailments
- * basic OWL axioms like ObjectProperty subClassOf Property
- * intersectionOf, equivalentClass and forward implication of unionOf sufficient for traversal of explicit class hierarchies
- * Property axioms (inverseOf, SymmetricProperty, TransitiveProperty, equivalentProperty)
-
- There is some experimental support for the cheaper class restriction handlingly which should not be relied on at this point.
-
-## Server Configuration
-
-If you need to load additional classes, or set global parameters, then these go in
-`FUSEKI_BASE/config.ttl`.
-
-Additional classes can not be loaded if running as a `.war` file. You will
-need to create a custom `.war` file consisting of the contents of the Fuseki
-web application and the additional classes
-
-### Server Section
-
- [] rdf:type fuseki:Server ;
- # Server-wide context parameters can be given here.
- # For example, to set query timeouts: on a server-wide basis:
- # Format 1: "1000" -- 1 second timeout
- # Format 2: "10000,60000" -- 10s timeout to first result, then 60s timeout to for rest of query.
- # See java doc for ARQ.queryTimeout
- # ja:context [ ja:cxtName "arq:queryTimeout" ; ja:cxtValue "10000" ] ;
-
- # Load custom code (rarely needed)
- # ja:loadClass "your.code.Class" ;
- .
-
-## Compatibility with Fuseki 1 configuration
+This only supports:
-Configurations from Fuseki 1, where all dataset and server setup is in a
-single configuration file, will still work. It is less flexible
-(you can't restart these services after stopping them in a running server)
-and user should plan to migrate to the [new layout](./fuseki-layout.html).
+* RDFS entailments
+* basic OWL axioms like ObjectProperty subClassOf Property
+* intersectionOf, equivalentClass and forward implication of unionOf sufficient for traversal of explicit class hierarchies
+* Property axioms (inverseOf, SymmetricProperty, TransitiveProperty, equivalentProperty)
-To convert a Fuseki 1 configuration setup to Fuseki 2 style, move each data service assembler and put in its own file under `FUSEKI_BASE/configuration/`
+ There is some experimental support for the cheaper class restriction handling which should not be relied on at this point.
diff --git a/source/documentation/fuseki2/data-access-control.md b/source/documentation/fuseki2/fuseki-data-access-control.md
similarity index 82%
rename from source/documentation/fuseki2/data-access-control.md
rename to source/documentation/fuseki2/fuseki-data-access-control.md
index b4b53d5..756c2f7 100644
--- a/source/documentation/fuseki2/data-access-control.md
+++ b/source/documentation/fuseki2/fuseki-data-access-control.md
@@ -7,16 +7,19 @@ on endpoints and also on specific graphs within a dataset. It also
provides native https to protect data in-flight.
[Fuseki Main](/documentation/fuseki2/fuseki-main.html)
-provides some common patterns of authentication.
-
-[Graph level Data Access Control](#graph-acl) provides control over the visibility of
+provides some common patterns of authentication and also
+[Graph level Data Access Control](#graph-acl) to provide control over the visibility of
graphs within a dataset, including the union graph of a dataset and
the default graph. Currently, Graph level access control only applies to
read-only datasets.
-Fuseki Full (Fuseki with the UI) can be used when
-[run in a web application server such as Tomcat](/documentation/fuseki2/fuseki-run.html#fuseki-web-application)
-to provide authentication of the user. See "[Fuseki Security](fuseki-security)" for configuring security over the whole of the Fuseki UI.
+Fuseki Full (Fuseki with the UI) can be used when [run in a web application
+server such as
+Tomcat](/documentation/fuseki2/fuseki-webapp.html#fuseki-web-application) to
+provide authentication of the user. See "[Fuseki Security](fuseki-security)"
+for configuring security over the whole of the Fuseki UI.
+
+This page applies to Fuseki Main.
## Contents
@@ -35,13 +38,12 @@ to provide authentication of the user. See "[Fuseki Security](fuseki-security)"
## HTTPS
-This section applies to Fuseki Main.
HTTPS support is configured from the fuseki server command line.
| Server Argument | | |
-|----------|----|--|
-| <tt>--https=<i>SETUP</i></tt> | Name of file for certificate details. | |
-| <tt>--httpsPort=<i>PORT</i></tt> | The port for https | Default: 3043 |
+| ----------------|----|--|
+| <tt>--https=<i>SETUP</i></tt> | Name of file for certificate details. | |
+| <tt>--httpsPort=<i>PORT</i></tt> | The port for https | Default: 3043 |
The `--https` argument names a file in JSON which includes the name of
the certificate file and password for the certificate.
@@ -75,8 +77,6 @@ for [generating certificates](http://www.eclipse.org/jetty/documentation/current
## Authentication
-This section applies to Fuseki Main.
-
[Authentication](https://en.wikipedia.org/wiki/Authentication),
is establishing the identity of the principal (user or program) accessing the
system. Fuseki Main provides users/password setup and HTTP authentication,
@@ -85,7 +85,7 @@ system. Fuseki Main provides users/password setup and HTTP authentication,
These should be [used with HTTPS](#https).
-| Server Argument | | |
+| Server Argument | | |
|------------------|-----|-----|
| <tt>--passwd=<i>FILE</i></tt> | Password file | |
| <tt>--auth=</tt> | "basic" or "digest" | Default is "digest" |
@@ -132,10 +132,10 @@ details. This section is a brief summary of some relevant options:
| wget argument | Value |--|
|----------------|-------|--|
-| `--http-user` | user name | Set the user.
-| `--http-password` | password | Set the password (visible to all on the local machine) |
-| | | `wget` uses users/password from `.wgetrc` or `.netrc` by default. |
-| `--no-check-certificate` | | Don't check HTTPS certificate.<br/> This allows for self-signed or expired, certificates or ones with the wrong host name. |
+| `--http-user` | user name | Set the user. |
+| `--http-password` | password | Set the password (visible to all on the local machine) |
+| | | `wget` uses users/password from `.wgetrc` or `.netrc` by default. |
+| `--no-check-certificate` | | Don't check HTTPS certificate.<br/> This allows for self-signed or expired, certificates or ones with the wrong host name. |
## Access Control Lists {#acl}
@@ -205,14 +205,19 @@ levels must allow the user access.
<b>fuseki:allowedUsers "user1", "user3";</b>
## Choice of operations.
- fuseki:serviceQuery "query" ;
- fuseki:serviceQuery "sparql" ;
- fuseki:serviceReadGraphStore "get" ;
-
- fuseki:serviceUpdate "update" ;
- fuseki:serviceUpload "upload" ;
- fuseki:serviceReadWriteGraphStore "data" ;
+ fuseki:endpoint [
+ fuseki:operation fuseki:query ;
+ fuseki:name "sparql"
+ ];
+ fuseki:endpoint [
+ fuseki:operation fuseki:update ;
+ fuseki:name "sparql"
+ ] ;
+ fuseki:endpoint [
+ fuseki:operation fuseki:gsp-r ;
+ fuseki:name "get"
+ ] ;
fuseki:dataset <#base_dataset>;
.
</pre>
@@ -223,10 +228,16 @@ An access control list can be applied to an individual endpoint.
Again, any other "allowedUsers" configuration, service-wide, or
server-wide) also applies.
- fuseki:serviceQuery [ fuseki:name "query" ;
- fuseki:allowedUsers "user1", "user2"] ;
- fuseki:serviceUpdate [ fuseki:name "update" ;
- fuseki:allowedUsers "user1"] ;
+ fuseki:endpoint [
+ fuseki:operation fuseki:query ;
+ fuseki:name "query" ;
+ fuseki:allowedUsers "user1", "user2" ;
+ ];
+ fuseki:endpoint [
+ fuseki:operation fuseki:update ;
+ fuseki:name "update" ;
+ fuseki:allowedUsers "user1"
+ ] ;
Only <em>user1</em> can use SPARQL update; both <em>user1</em> and
<em>user2</em> can use SPARQL query.
@@ -247,13 +258,13 @@ Graph ACLs are defined in a [Graph Security Registry](#graph-security-registry)
<#service_tdb2> rdf:type fuseki:Service ;
rdfs:label "Graph-level access controlled dataset" ;
fuseki:name "db-graph-acl" ;
- ## Read-only operations.
- fuseki:serviceQuery "query" ;
- fuseki:serviceQuery "sparql" ;
- fuseki:serviceReadGraphStore "get" ;
+ ## Read-only operations on the dataset URL.
+ fuseki:endpoint [ fuseki:operation fuseki:query ] ;
+ fuseki:endpoint [ fuseki:operation fuseki:gsp_r ] ;
fuseki:dataset <b><#access_dataset></b> ;
.
+ # Define access on the dataset.
<#access_dataset> rdf:type access:AccessControlledDataset ;
access:registry <#securityRegistry> ;
access:dataset <#tdb_dataset_shared> ;
diff --git a/source/documentation/fuseki2/fuseki-data-services.md b/source/documentation/fuseki2/fuseki-data-services.md
index a5e08c8..92f0256 100644
--- a/source/documentation/fuseki2/fuseki-data-services.md
+++ b/source/documentation/fuseki2/fuseki-data-services.md
@@ -17,7 +17,7 @@ update
GSP including direct naming for GSP
in addition:
-
+fuse
Dataset as a set of quads.
diff --git a/source/documentation/fuseki2/fuseki-docker.md b/source/documentation/fuseki2/fuseki-docker.md
new file mode 100644
index 0000000..2aa52d3
--- /dev/null
+++ b/source/documentation/fuseki2/fuseki-docker.md
@@ -0,0 +1,112 @@
+---
+title: Fuseki : Docker Tools
+---
+
+The [jena-fuseki-docker package](https://repo1.maven.org/maven2/org/apache/jena/jena-fuseki-docker/)
+contains a Dockerfile, docker-compose file, and helper scripts to
+create a docker container for Apache Jena Fuseki.
+
+The docker container is based on
+[Fuseki main](https://jena.apache.org/documentation/fuseki2/fuseki-main)
+for running a SPARQL server.
+
+There is no UI - all configuration is by command line and all usage by via the
+network protocols.
+
+Databases can be mounted outside the docker container so they are preserved when
+the container terminates.
+
+This build system allows the user to customize the docker image.
+
+The docker build downloads the server binary from
+[Maven central](https://repo1.maven.org/maven2/org/apache/jena/jena-fuseki-server/),
+checking the download against the SHA1 checksum.
+
+## Database
+
+There is a volume mapping "./databases" in the current directory into the server.
+This can be used to contain databases outside, but accessible to, the container
+that do not get deleted when the container exits.
+
+See examples below.
+
+## Build
+
+Choose the version number of Apache Jena release you wish to use. This toolkit
+defaults to the version of the overall Jena release it was part of. It is best
+to use the release of this set of tools from the same release of the desired
+server.
+
+ docker-compose build --build-arg JENA_VERSION=3.16.0
+
+Note the build command must provide the version number.
+
+## Test Run
+
+`docker-compose run` cam be used to test the build from the previous section.
+
+Examples:
+
+Start Fuseki with an in-memory, updatable dataset at http://<i>host</i>:3030/ds
+
+ docker-compose run --rm --service-ports fuseki --mem /ds
+
+Load a TDB2 database, and expose, read-only, via docker:
+
+ mkdir -p databases/DB2
+ tdb2.tdbloader --loc databases/DB2 MyData.ttl
+ # Publish read-only
+ docker-compose run --rm --name MyServer --service-ports fuseki --tdb2 --loc databases/DB2 /ds
+
+To allow update on the database, add `--update`. Updates are persisted.
+
+ docker-compose run --rm --name MyServer --service-ports fuseki --tdb2 --update --loc databases/DB2 /ds
+
+See
+[fuseki-configuration](https://jena.apache.org/documentation/fuseki2/fuseki-configuration.html)
+for more information on command line arguments.
+
+To use `docker-compose up`, edit the `docker-compose.yaml` to set the Fuseki
+command line arguments appropriately.
+
+## Layout
+
+The default layout in the container is:
+
+| Path | Use |
+| ----- | --- |
+| /opt/java-minimal | A reduced size Java runtime |
+| /fuseki | The Fuseki installation |
+| /fuseki/log4j2.properties | Logging configuration |
+| /fuseki/databases/ | Directory for a volume for persistent databases |
+
+## Setting JVM arguments
+
+Use `JAVA_OPTIONS`:
+
+ docker-compose run --service-ports --rm -e JAVA_OPTIONS="-Xmx1048m -Xms1048m" --name MyServer fuseki --mem /ds
+
+## Docker Commands
+
+If you prefer to use `docker` directly:
+
+Build:
+
+ docker build --force-rm --build-arg JENA_VERSION=3.16.0 -t fuseki .
+
+Run:
+
+ docker run -i --rm -p "3030:3030" --name MyServer -t fuseki --mem /ds
+
+With databases on a bind mount to host filesystem directory:
+
+ MNT="--mount type=bind,src=$PWD/databases,dst=/fuseki/databases"
+ docker run -i --rm -p "3030:3030" $MNT --name MyServer -t fuseki --tdb2 --update --loc databases/DB2 /ds
+
+## Version specific notes:
+
+* Versions of Jena up to 3.14.0 use Log4j1 for logging. The docker will build will ignore
+ the log4j2.properties file
+* Version 3.15.0: When run, a warning will be emitted.
+ `WARNING: sun.reflect.Reflection.getCallerClass is not supported. This will impact performance.`
+ This can be ignored.
diff --git a/source/documentation/fuseki2/fuseki-main.md b/source/documentation/fuseki2/fuseki-embedded.md
similarity index 72%
copy from source/documentation/fuseki2/fuseki-main.md
copy to source/documentation/fuseki2/fuseki-embedded.md
index d16e651..0faad60 100644
--- a/source/documentation/fuseki2/fuseki-main.md
+++ b/source/documentation/fuseki2/fuseki-embedded.md
@@ -1,51 +1,14 @@
---
-title: "Fuseki : Main Server"
+title: Fuseki : Emdedded Server
---
-Fuseki main is a packaging of Fuseki as a triple store without a UI for administration.
+Fuseki can be run within a larger JVM application as an embedded triplestore.
-
-Fuseki can be run in the background by an application as an embedded server. The
-application can safely work with the dataset directly from java while having Fuseki
-provide SPARQL access over HTTP. An embedded server is useful for
-adding functionality around a triple store and also for development and testing.
-
-* [Running as a deployment or development server](#fuseki-server)
-* [Application Use](#usage)
* [Dependencies and Setup](#dependencies)
* [Logging](#logging)
* [Building a Server](#build)
* [Examples](#examples)
-The main server does not depend on any files on disk (other than for
-databases provided by the application), and does not provide the Fuseki
-UI or admins functions to create dataset via HTTP.
-
-See also [Data Access Control for Fuseki](data-access-control).
-
-## Running as a configured deployment or development server {#fuseki-server}
-
-The artifact `org.apache.jena:jena-fuseki-server` is a packaging of
-the "main" server that runs from the command line. Unlike the UI
-Fuseki server, it is only configured from the command line and has no
-persistent work area on-disk.
-
- java -jar jena-fuseki-server-$VER.jar --help
-
-The arguments are the same as the
-[full UI server command line program](/documentation/fuseki2/fuseki-run.html#fuseki-standalone-server).
-There are no special environment variables.
-
-
-The entry point is `org.apache.jena.fuseki.main.cmds.FusekiMainCmd` so
-the server can also be run as:
-
- java -cp jena-fuseki-server-$VER.jar:...OtherJars... \
- org.apache.jena.fuseki.main.cmds.FusekiMainCmd ARGS
-
-
-## Application Use {#usage}
-
The application can safely access and modify the data published by the server if it does
so inside a [transaction](/documentation/txn/) using an appropriate
storage choice. `DatasetFactory.createTxnMem()` is a good choice for in-memory use;
@@ -80,7 +43,7 @@ or read the dataset and see any updates made by remote systems:
The full Jena API can be used provided operations (read and write) are inside
a transaction.
-## Dependencies and Setup {#dependencies}
+### Dependencies and Setup {#dependencies}
To include an embedded Fuseki server in the application:
@@ -95,29 +58,16 @@ encouraged to use a dependency manager because the number of Jetty and other dep
is quite large and difficult to set manually.
This dependency does not include a logging setting. Fuseki uses [slf4j](http://slf4j.org/).
-See section "[Logging](#logging)" for details.
If the application wishes to use a dataset with a [text-index](/documentation/query/text-query.html)
then the application will also need to include jena-text in its dependencies.
-## Logging {#logging}
+### Logging {#logging}
The application must set the logging provided for [slf4j](http://slf4j.org/).
-Apache Jena provides helpers for the JDK-provided java logging and for Apache Log4j v2.
-
-Using the JDK-provided java logging:
-
- LogCtl.setJavaLogging()
-
-and a dependency of:
-
- <dependency>
- <groupId>org.slf4j</groupId>
- <artifactId>slf4j-jdk14</artifactId>
- <version>1.x.y</version>
- </dependency>
+Apache Jena provides helpers Apache Log4j v2.
-For Apache Log4j2: - this is how the full Fuseki server sets its logging:
+For Apache Log4j2, call:
FusekiLogging.setLogging();
diff --git a/source/documentation/fuseki2/fuseki-logging.md b/source/documentation/fuseki2/fuseki-logging.md
index 2d24bfd..70ffb3c 100644
--- a/source/documentation/fuseki2/fuseki-logging.md
+++ b/source/documentation/fuseki2/fuseki-logging.md
@@ -9,7 +9,6 @@ Logging is via [SLF4J](http://slf4j.org/) over
the Tomcat configuration if running the WAR file.
-
| Full Log name | Usage |
|--------------- |-------|
| org.apache.jena.fuseki.Server | General Server Messages |
@@ -25,6 +24,7 @@ This log is in NCSA extended/combined log format.
Many web log analysers can process this format.
This log is normally off.
+The logger name is `org.apache.jena.fuseki.Request`.
When run as a WAR file inside a webapp container
(e.g. [Apache Tomcat](http://tomcat.apache.org/)), the webapp container
@@ -36,7 +36,7 @@ The Fuseki engine looks for the log4j2 configuration as follows:
* Use system property `log4j2.configurationFile` if defined ([as usual for log4j2](https://logging.apache.org/log4j/2.x/manual/configuration.html)).
* Use `file:log4j2.properties` (current directory) if it exists
-* Use file `log4j2.properties` is the directory defined by `FUSEKI_BASE`
+* Use file `log4j2.properties` in the directory defined by `FUSEKI_BASE` (webapp)
* Use java resource `log4j2.properties` on the classpath.
* Use java resource `org/apache/jena/fuseki/log4j2.properties` on the classpath.
* Use a built-in configuration.
@@ -45,10 +45,14 @@ The last step is a fallback to catch the case where Fuseki has been repackaged
into a new WAR file and `org/apache/jena/fuseki/log4j.properties` omitted, or run from
the base jar. It is better to include `org/apache/jena/fuseki/log4j.properties`.
-The preferred customization is to use a custom `log4j2.properties` file in
-`FUSEKI_BASE`. For the WAR file, `FUSEKI_BASE` defaults to `/etc/fuseki`
-on Linux. For the standalone server, `FUSEKI_BASE` defaults to directory
-`run/` within the directory where the server is run.
+The preferred customization is to use a custom `log4j2.properties` file in the
+directory where Fuseki Main is run.
+
+For the war file packaging, the `log4j2.properties` shoudl go in `FUSEKI_BASE`
+which defaults to `/etc/fuseki` on Linux.
+
+For the standalone webapp server, `FUSEKI_BASE` defaults to directory `run/`
+within the directory where the server is run.
## Default setting
@@ -59,7 +63,7 @@ The [default log4j2.properties](https://github.com/apache/jena/blob/master/jena-
Below is an example logrotate(1) configuration (to go in `/etc/logrotate.d`)
assuming the log file has been put in `/etc/fuseki/logs/fuseki.log`.
-It rotates the logs once a month, compresses logs on rotation and keeps them for 6 months.
+It rotates the logs once a month, compresses logs on rotation, and keeps them for 6 months.
It uses `copytruncate`. This may lead to at most one broken log file line.
diff --git a/source/documentation/fuseki2/fuseki-main.md b/source/documentation/fuseki2/fuseki-main.md
index d16e651..1674146 100644
--- a/source/documentation/fuseki2/fuseki-main.md
+++ b/source/documentation/fuseki2/fuseki-main.md
@@ -1,27 +1,27 @@
---
-title: "Fuseki : Main Server"
+title: Fuseki : Main Server
---
Fuseki main is a packaging of Fuseki as a triple store without a UI for administration.
-
Fuseki can be run in the background by an application as an embedded server. The
application can safely work with the dataset directly from java while having Fuseki
provide SPARQL access over HTTP. An embedded server is useful for
adding functionality around a triple store and also for development and testing.
* [Running as a deployment or development server](#fuseki-server)
-* [Application Use](#usage)
-* [Dependencies and Setup](#dependencies)
-* [Logging](#logging)
-* [Building a Server](#build)
-* [Examples](#examples)
+* [Running from Docker](#fuseki-docker)
+* [Running as an embedded server](fuseki-embedded.html)
+ * [Dependencies and Setup](fuseki-embedded.html#dependencies)
+ * [Logging](fuseki-embedded.html#logging)
+ * [Building a Server](fuseki-embedded.html#build)
+ * [Examples](fuseki-embedded.html#examples)
The main server does not depend on any files on disk (other than for
databases provided by the application), and does not provide the Fuseki
UI or admins functions to create dataset via HTTP.
-See also [Data Access Control for Fuseki](data-access-control).
+See also [Data Access Control for Fuseki](./fuseki-data-access-control.html).
## Running as a configured deployment or development server {#fuseki-server}
@@ -33,201 +33,38 @@ persistent work area on-disk.
java -jar jena-fuseki-server-$VER.jar --help
The arguments are the same as the
-[full UI server command line program](/documentation/fuseki2/fuseki-run.html#fuseki-standalone-server).
+[full UI server command line program](/documentation/fuseki2/fuseki-webapp.html#fuseki-standalone-server).
There are no special environment variables.
-
The entry point is `org.apache.jena.fuseki.main.cmds.FusekiMainCmd` so
the server can also be run as:
java -cp jena-fuseki-server-$VER.jar:...OtherJars... \
org.apache.jena.fuseki.main.cmds.FusekiMainCmd ARGS
+## Docker {#fuseki-docker}
-## Application Use {#usage}
-
-The application can safely access and modify the data published by the server if it does
-so inside a [transaction](/documentation/txn/) using an appropriate
-storage choice. `DatasetFactory.createTxnMem()` is a good choice for in-memory use;
-[TDB](/documentation/tdb/) is a good choice for a persistent database.
-
-To build and start the server:
-
- Dataset ds = ...
- FusekiServer server = FusekiServer.create()
- .add("/rdf", ds)
- .build() ;
- server.start() ;
-
-then the application can modify the dataset:
-
- // Add some data while live.
- // Write transaction.
- Txn.execWrite(dsg, ()->RDFDataMgr.read(dsg, "D.trig")) ;
-
-or read the dataset and see any updates made by remote systems:
-
- // Query data while live
- // Read transaction.
- Txn.execRead(dsg, ()->{
- Dataset ds = DatasetFactory.wrap(dsg) ;
- try (QueryExecution qExec = QueryExecutionFactory.create("SELECT * { ?s ?o}", ds) ) {
- ResultSet rs = qExec.execSelect() ;
- ResultSetFormatter.out(rs) ;
- }
- }) ;
-
-The full Jena API can be used provided operations (read and write) are inside
-a transaction.
-
-## Dependencies and Setup {#dependencies}
-
-To include an embedded Fuseki server in the application:
-
- <dependency>
- <groupId>org.apache.jena</groupId>
- <artifactId>jena-fuseki-main</artifactId>
- <version>3.x.y</version> <!-- Set the version -->
- </dependency>
-
-This brings in enough dependencies to run Fuseki. Application writers are strongly
-encouraged to use a dependency manager because the number of Jetty and other dependencies
-is quite large and difficult to set manually.
-
-This dependency does not include a logging setting. Fuseki uses [slf4j](http://slf4j.org/).
-See section "[Logging](#logging)" for details.
-
-If the application wishes to use a dataset with a [text-index](/documentation/query/text-query.html)
-then the application will also need to include jena-text in its dependencies.
-
-## Logging {#logging}
-
-The application must set the logging provided for [slf4j](http://slf4j.org/).
-Apache Jena provides helpers for the JDK-provided java logging and for Apache Log4j v2.
-
-Using the JDK-provided java logging:
-
- LogCtl.setJavaLogging()
-
-and a dependency of:
-
- <dependency>
- <groupId>org.slf4j</groupId>
- <artifactId>slf4j-jdk14</artifactId>
- <version>1.x.y</version>
- </dependency>
-
-For Apache Log4j2: - this is how the full Fuseki server sets its logging:
+A kit to build a container with docker or docker compose
- FusekiLogging.setLogging();
+ https://repo1.maven.org/maven2/org/apache/jena/jena-fuseki-docker/
-and dependency:
+Note; take care thet databases are on mounted volumes if they are to peristent
+after the container is removed.
- <dependency>
- <groupId>org.apache.logging.log4j</groupId>
- <artifactId>log4j-slf4j-impl</artifactId>
- <version>2.13.1</version> <!-- Many versions work -->
- </dependency>
+See the [Fuseki docker tools page](fuseki-docker.html) for details.
-See [Fuseki Logging](/documentation/fuseki2/fuseki-logging.html).
+## Running as an embedded server
-To silence logging from Java, try:
+Fuseki can be run from inside an Java application to provide SPARQL
+services to application data. The application can continue to access and
+update the datasets served by the server.
- LogCtl.setLevel(Fuseki.serverLogName, "WARN");
- LogCtl.setLevel(Fuseki.actionLogName, "WARN");
- LogCtl.setLevel(Fuseki.requestLogName, "WARN");
- LogCtl.setLevel(Fuseki.adminLogName, "WARN");
- LogCtl.setLevel("org.eclipse.jetty", "WARN");
-
-## Building a server {#build}
-
-A ``FusekiServer`` is built by creating a configuration,
-building the server, then running it. The application needs to start
-the server.
-
-The default port for a Fuseki embedded server is 3330. This is different for the default
-port for Fuseki running as a standalone server or as a webapp application.
-
-## Examples of embedded use {#examples}
-
-### Example 1
-Create a server on port 3330, that provides the default set of endpoints for an RDF
-dataset that can be updated via HTTP.
-
- DatasetGraph ds = DatasetFactory.createTxnMem() ;
- FusekiServer server = FusekiServer.create()
- .add("/ds", ds)
- .build() ;
- server.start() ;
- ...
- server.stop() ;
-
-URLs:
-
-| Service | Endpoint |
-|---------|----------|
-| SPARQL Query | ``http://host:3330/ds/query`` |
-| SPARQL Query | ``http://host:3330/ds/sparql`` |
-| SPARQL Update | ``http://host:3330/ds/update`` |
-| File upload | ``http://host:3330/ds/update`` |
-| GSP read-write | ``http://host:3330/ds/data`` |
-| Read-write quads | ``http://host:3330/ds`` |
-
-"GSP" = SPARQL Graph Store Protocol
-
-### Example 2
-Create a server on port 3332, that provides the default set of endpoints for a data
-set that is read-only over HTTP. The application can still update the dataset.
-
- Dataset ds = ... ;
- FusekiServer server = FusekiServer.create()
- .setPort(3332)
- .add("/ds", ds, true)
- .build() ;
- server.start() ;
-
-| Service | Endpoint |
-|---------|----------|
-| SPARQL Query | ``http://host:3332/ds/query`` |
-| SPARQL Query | ``http://host:3332/ds/sparql`` |
-| GSP read-only | ``http://host:3332/ds/data`` |
-| GET quads | ``http://host:3332/ds`` |
-
-### Example 3
-
-Different combinations of services and endpoint names can be given using a `DataService`.
-
- DatasetGraph dsg = ... ;
- DataService dataService = new DataService(dsg) ;
- dataService.addEndpoint(OperationName.Quads_RW, "");
- dataService.addEndpoint(OperationName.Query, "");
- dataService.addEndpoint(OperationName.Update, "");
+To build and start the server:
+ Dataset ds = ...
FusekiServer server = FusekiServer.create()
- .setPort(3332)
- .add("/data", dataService)
- .build() ;
+ .add("/dataset", ds)
+ .build() ;
server.start() ;
-This setup puts all the operation on the dataset URL. The ``Content-type`` and any query
-string is used to determine the operation.
-
-| Service | Endpoint |
-|---------|----------|
-| SPARQL Query | ``http://host:3332/ds`` |
-| SPARQL Update | ``http://host:3332/ds`` |
-| GSP read-only | ``http://host:3332/ds`` |
-| GET/POST quads | ``http://host:3332/ds`` |
-
-### Example 4
-
-Multiple datasets can be served by one server.
-
- Dataset ds1 = ...
- Dataset ds2 = ...
- FusekiServer server = FusekiServer.create()
- .add("/data1", ds1)
- .add("/data1-readonly", ds1, true)
- .add("/data2", ds2)
- .build() ;
- server.start() ;
+See [Fuseki embedded documentation](fuseki-embedded.html) for details and examples.
diff --git a/source/documentation/fuseki2/fuseki-old-config-endpoint.md b/source/documentation/fuseki2/fuseki-old-config-endpoint.md
new file mode 100644
index 0000000..1df1253
--- /dev/null
+++ b/source/documentation/fuseki2/fuseki-old-config-endpoint.md
@@ -0,0 +1,55 @@
+---
+title: Fuseki Data Service Configuration Syntax - Old Style
+---
+
+This page describes the original Fuseki2 server configuration syntax.
+
+Example:
+
+ ## Updatable dataset.
+
+ <#service1> rdf:type fuseki:Service ;
+ fuseki:name "ds" ; # http://host:port/ds
+ fuseki:serviceQuery "sparql" ; # SPARQL query service
+ fuseki:serviceQuery "query" ; # SPARQL query service (alt name)
+ fuseki:serviceUpdate "update" ; # SPARQL update service
+ fuseki:serviceUpload "upload" ; # Non-SPARQL upload service
+ fuseki:serviceReadWriteGraphStore "data" ; # SPARQL Graph Store Protocol (read and write)
+ fuseki:serviceReadGraphStore "get" ; # SPARQL Graph Store Protocol (read only)
+ fuseki:dataset <#dataset> ;
+ .
+
+`<#dataset>` refers to a dataset description in the same file.
+
+There are fixed set of services:
+
+| Service | Description |
+|---------|-------------|
+| fuseki:serviceQuery | SPARQL query service |
+| fuseki:serviceUpdate | SPARQL update service |
+| fuseki:serviceUpload | Non-SPARQL HTML file upload service |
+| fuseki:serviceReadGraphStore | SPARQL Graph Store Protocol (read)
+| fuseki:serviceReadWriteGraphStore | SPARQL Graph Store Protocol (read and write)
+
+Configuration syntax can be mixed. If there are both old style and new style
+configurations for the same endpoint, the new style configuration is used.
+
+Quads operations on dataset are implied if there is a SPARQL Graph Store
+Protocol service configured.
+
+If a request is made on the dataset (no service name in the request URL), then
+the dispatcher classifies the operation and looks for a named endpoint for that
+operation of any name. If one is found, that is used.
+In the [full endpoint configuration syntax](fuseki-config-endpoint.html), the
+additional dataset services are specified explicitly.
+
+The equivalent of
+
+ fuseki:serviceQuery "sparql" ;
+
+is
+
+ fuseki:endpoint [ fuseki:operation fuseki:query ; ];
+ fuseki:endpoint [ fuseki:operation fuseki:query ; fuseki:name "sparql" ];
+
+and the two endpoint can have different contetx setting and security.
diff --git a/source/documentation/fuseki2/fuseki-quick-start.md b/source/documentation/fuseki2/fuseki-quick-start.md
index 9a62ad8..fc8e122 100644
--- a/source/documentation/fuseki2/fuseki-quick-start.md
+++ b/source/documentation/fuseki2/fuseki-quick-start.md
@@ -23,7 +23,7 @@ This page describes how to achieve certain common tasks in the most direct way p
2. Run `fuseki-server --loc=DATABASE /name`
3. In a browser, go to `http://localhost:3030//query.html`
-More details on running Fuseki can be found [nearby](fuseki-run.html),
+More details on running Fuseki can be found [nearby](fuseki-webapp.html),
including running as an operating system service and in a web app or
servlet container such as [Apache Tomcat](http://tomcat.apache.org/) or
[Jetty](http://eclipse.org/jetty).
diff --git a/source/documentation/fuseki2/fuseki-security.md b/source/documentation/fuseki2/fuseki-security.md
index 0b01367..23f615f 100644
--- a/source/documentation/fuseki2/fuseki-security.md
+++ b/source/documentation/fuseki2/fuseki-security.md
@@ -2,7 +2,7 @@
title: Security in Fuseki2
---
-Fuseki2 provides security by using [Apache Shiro](http://shiro.apache.org/).
+Fuseki2 webapp provides security by using [Apache Shiro](http://shiro.apache.org/).
This is controlled by the configuration file `shiro.ini` located at
`$FUSEKI_BASE/shiro.ini`. If not found, the server initializes with a default
configuration. This can then be replaced or edited as required. An existing file
@@ -88,6 +88,3 @@ It adds a `[users]` section and changes the `/$/**` line in `[urls]`
/$/** = authcBasic,user[admin]
# Everything else
/**=anon
-
-
-
diff --git a/source/documentation/fuseki2/fuseki-server-info.md b/source/documentation/fuseki2/fuseki-server-info.md
new file mode 100644
index 0000000..89c774e
--- /dev/null
+++ b/source/documentation/fuseki2/fuseki-server-info.md
@@ -0,0 +1,116 @@
+---
+title: "Fuseki: Server Information"
+---
+
+A Fuseki server keeps detailed statistics for each dataset and each service
+of a dataset keeps counters as to the number
+of incoming requests, number of successful requests, number of bad requests
+(i.e client errors), and number of failing requests (i.e. server errors).
+
+Statistics are avilable in JSON and in [Prometheus](https://prometheus.io/)
+format. The Promethues data includes both database and JVM metrics.
+
+## Endpoints
+
+The following servers endpoints are avilable. They are present in Fuseki/UI;
+they need to be enabled with [Fuseki/main](fuseki-main.html), either on the
+command line or in the server configuration file with a boolean setting.
+
+| Endpoint | Config Property | Usage |
+|----------|-----------------|-------|
+|`/$/ping` | `fuseki:pingEP` | Server liveness endpoint |
+|`/$/stats` | `fuseki:statsEP` | JSON format endpoint |
+|`/$/metrics`| `fuseki:metricsEP` | Prometheus format endpoint |
+
+## Ping
+
+The "ping" service can be used to test whether a Fuseki server is running.
+Calling this endpoint imposes minimal overhea don the server. Requests return
+the current time as a plain text string so to show the ping is current.
+
+HTTP GET and HTTP POST are supported. The GET request is marked "no-cache".
+
+## Structure of the Statistics Report
+
+The statistics report shows the endpoints for each dataset with total counts of requests,
+good request and bad requests.
+
+
+## Example
+
+Endpoints with the format "_1" etc are unnamed services of the dataset.
+
+ {
+ "datasets" : {
+ "/ds" : {
+ "Requests" : 0 ,
+ "RequestsGood" : 0 ,
+ "RequestsBad" : 0 ,
+ "endpoints" : {
+ "data" : {
+ "RequestsBad" : 0 ,
+ "Requests" : 0 ,
+ "RequestsGood" : 0 ,
+ "operation" : "gsp-rw" ,
+ "description" : "Graph Store Protocol"
+ } ,
+ "_1" : {
+ "RequestsBad" : 0 ,
+ "Requests" : 0 ,
+ "RequestsGood" : 0 ,
+ "operation" : "gsp-rw" ,
+ "description" : "Graph Store Protocol"
+ } ,
+ "_2" : {
+ "RequestsBad" : 0 ,
+ "Requests" : 0 ,
+ "RequestsGood" : 0 ,
+ "operation" : "query" ,
+ "description" : "SPARQL Query"
+ } ,
+ "query" : {
+ "RequestsBad" : 0 ,
+ "Requests" : 0 ,
+ "RequestsGood" : 0 ,
+ "operation" : "query" ,
+ "description" : "SPARQL Query"
+ } ,
+ "sparql" : {
+ "RequestsBad" : 0 ,
+ "Requests" : 0 ,
+ "RequestsGood" : 0 ,
+ "operation" : "query" ,
+ "description" : "SPARQL Query"
+ } ,
+ "get" : {
+ "RequestsBad" : 0 ,
+ "Requests" : 0 ,
+ "RequestsGood" : 0 ,
+ "operation" : "gsp-r" ,
+ "description" : "Graph Store Protocol (Read)"
+ } ,
+ "update" : {
+ "RequestsBad" : 0 ,
+ "Requests" : 0 ,
+ "RequestsGood" : 0 ,
+ "operation" : "update" ,
+ "description" : "SPARQL Update"
+ } ,
+ "_3" : {
+ "RequestsBad" : 0 ,
+ "Requests" : 0 ,
+ "RequestsGood" : 0 ,
+ "operation" : "update" ,
+ "description" : "SPARQL Update"
+ } ,
+ "upload" : {
+ "RequestsBad" : 0 ,
+ "Requests" : 0 ,
+ "RequestsGood" : 0 ,
+ "operation" : "upload" ,
+ "description" : "File Upload"
+ }
+ }
+ }
+ }
+ }
diff --git a/source/documentation/fuseki2/fuseki-server-protocol.md b/source/documentation/fuseki2/fuseki-server-protocol.md
index 16796f6..5f5a002 100644
--- a/source/documentation/fuseki2/fuseki-server-protocol.md
+++ b/source/documentation/fuseki2/fuseki-server-protocol.md
@@ -137,7 +137,7 @@ Statistics can be obtained for each dataset or all datasets in a single response
`/$/stats` is treated as a container for this information.
> _@@ stats details_
-> See [Fuseki Statistics](fuseki-stats.html) for details of statistics kept by a Fuseki server.
+> See [Fuseki Server Information](fuseki-server-info.html) for details of statistics kept by a Fuseki server.
### Backup
Pattern: `/$/backup/*{name}*`
diff --git a/source/documentation/fuseki2/fuseki-stats.md b/source/documentation/fuseki2/fuseki-stats.md
deleted file mode 100644
index 3e1b4ea..0000000
--- a/source/documentation/fuseki2/fuseki-stats.md
+++ /dev/null
@@ -1,115 +0,0 @@
----
-title: "Fuseki: Service Statistics"
----
-
-A Fuseki server keeps detailed statistics for each dataset and each service
-of a dataset keeps counters as to the number
-of incoming requests, number of successful requests, number of bad requests
-(i.e client errors), and number of failing requests (i.e. server errors).
-Statistics are returned as JSON. They are also available via JMX.
-
-## Structure of the Statistics Report
-
-### SPARQL Protocol Service
-
-Query and Update
-
-### SPARQL Graph Store Protocol
-
-inc extensions - dataset HTTP verbs.
-
-#### Other services.
-
-File upload.
-
-## Example
-
- { "datasets" : {
- "/ds" :
- { "Requests" : 0 ,
- "RequestsBad" : 0 ,
- "RequestsGood" : 0 ,
- "services" : {
- "query" :
- {"QueryExecErrors" : 0 ,
- "QueryTimeouts" : 0 ,
- "Requests" : 0 ,
- "RequestsBad" : 0 ,
- "RequestsGood" : 0 ,
- "endpoints" : [
- "query" ,
- "sparql"
- ]
- } ,
- "update" :
- {"Requests" : 0 ,
- "RequestsBad" : 0 ,
- "RequestsGood" : 0 ,
- "UpdateExecErrors" : 0 ,
- "endpoints" : [ ]
- } ,
- "upload" :
- {"Requests" : 0 ,
- "RequestsBad" : 0 ,
- "RequestsGood" : 0 ,
- "endpoints" : [ ]
- } ,
-
- "gspRead" :
- {"GSPdelete" : 0 ,
- "GSPdeleteBad" : 0 ,
- "GSPdeleteGood" : 0 ,
- "GSPget" : 0 ,
- "GSPgetBad" : 0 ,
- "GSPgetGood" : 0 ,
- "GSPhead" : 0 ,
- "GSPheadBad" : 0 ,
- "GSPheadGood" : 0 ,
- "GSPoptions" : 0 ,
- "GSPoptionsBad" : 0 ,
- "GSPoptionsGood" : 0 ,
- "GSPpatch" : 0 ,
- "GSPpatchBad" : 0 ,
- "GSPpatchGood" : 0 ,
- "GSPpost" : 0 ,
- "GSPpostBad" : 0 ,
- "GSPpostGood" : 0 ,
- "GSPput" : 0 ,
- "GSPputBad" : 0 ,
- "GSPputGood" : 0 ,
- "Requests" : 0 ,
- "RequestsBad" : 0 ,
- "RequestsGood" : 0 ,
- "endpoints" : [ "data" ]
- } ,
- "gspReadWrite" :
- {"GSPdelete" : 0 ,
- "GSPdeleteBad" : 0 ,
- "GSPdeleteGood" : 0 ,
- "GSPget" : 0 ,
- "GSPgetBad" : 0 ,
- "GSPgetGood" : 0 ,
- "GSPhead" : 0 ,
- "GSPheadBad" : 0 ,
- "GSPheadGood" : 0 ,
- "GSPoptions" : 0 ,
- "GSPoptionsBad" : 0 ,
- "GSPoptionsGood" : 0 ,
- "GSPpatch" : 0 ,
- "GSPpatchBad" : 0 ,
- "GSPpatchGood" : 0 ,
- "GSPpost" : 0 ,
- "GSPpostBad" : 0 ,
- "GSPpostGood" : 0 ,
- "GSPput" : 0 ,
- "GSPputBad" : 0 ,
- "GSPputGood" : 0 ,
- "Requests" : 0 ,
- "RequestsBad" : 0 ,
- "RequestsGood" : 0 ,
- "endpoints" : [ ]
- }
- }
- }
- }
- }
diff --git a/source/documentation/fuseki2/fuseki-run.md b/source/documentation/fuseki2/fuseki-webapp.md
similarity index 53%
rename from source/documentation/fuseki2/fuseki-run.md
rename to source/documentation/fuseki2/fuseki-webapp.md
index 6d9892c..bb3741a 100644
--- a/source/documentation/fuseki2/fuseki-run.md
+++ b/source/documentation/fuseki2/fuseki-webapp.md
@@ -1,48 +1,71 @@
---
-title: Running Fuseki
+title: Running Fuseki with UI
---
-Fuseki can be run in a number of ways:
+Fuseki/UI can be run in a number of ways:
* [As a standalone server](#fuseki-standalone-server)
* [As a service](#fuseki-service) run by the operation system, for example, started when the machine
* [As a Web Application](#fuseki-web-application) inside a container such as Apache Tomcat or Jetty
boots.
-* [As a configurable SPARQL server](#fuseki-main)
-* [As a deployment and development standalone server](#fuseki-server)
+
+Fuseki is also packaged as a plain server ["Fuseki Main"](fuseki-main.html)
+with no UI for use as a configurable SPARQL server, for [building as a Docker
+container](fuseki-docker.html), and as a deployment and development standalone
+server.
+
+Both packaging used the same configuration file format, and in standalone server
+mode, the same command line arguments.
See "[Fuseki Configuration](fuseki-configuration.html)" for information on
-how to provide datasets and configure services.
+how to provide datasets and configure services usoing the configuration file.
## Fuseki as a Standalone Server {#fuseki-standalone-server}
This is running Fuseki from the command line.
- fuseki-server [--mem | --loc=DIR] [[--update] /NAME]
-
- fuseki-server --config=CONFIG
+To publish at <tt>http://<i>host</i>:3030/NAME</i></tt>:
where `/NAME` is the dataset publishing name at this server in URI space.
+TDB1 database:
+
+ fuseki-server [--loc=DIR] [[--update] /NAME]
+
The argument `--tdb2` puts the command line handling into "TDB2 mode".
A dataset created with `--loc` is a TDB2 dataset.
+TDB2 database:
+
+ fuseki-server --tdb2 [--loc=DIR] [[--update] /NAME]
+
+In-memory, non-peristent database (always updatable):
+
+ fuseki-server --mem /NAME
+
+Load a file at start and provide it read-only:
+
+ fuseki-server --file=MyData.ttl /NAME
+
+where "MyData.ttl" can be any RDF format, both triples or quads.
+
+Administrative functions are only avilable from "localhost".
See `fuseki-server --help` for details of more arguments.
-`FUSEKI_BASE`, the runtime area for the server instance, defaults to the
-`run/` directory of the current directory.
+## Layout
+
+When run from the command line, the server creates its work area in the
+directory named by environment variable `FUSEKI_BASE`. When run from the
+commandline, this defaults to the current directory.
-Fuseki v2 supports the same style of configuration file as Fuseki v1 but it
-is better to separate the data service definitions from the server
-configuration with one definition per file in `FUSEKI_BASE/configuration`;
-see "[Fuseki Configuration](fuseki-configuration.html)".
+[Fuseki layout](fuseki-layout.md)
If you get the error message `Can't find jarfile to run` then you either
need to put a copy of `fuseki-server.jar` in the current directory or set
the environment variable `FUSEKI_HOME` to point to an unpacked Fuseki
distribution.
-Unlike Fuseki v1, starting with no dataset and no configuration is possible.
+Starting with no dataset and no configuration is possible.
Datasets can be added from the admin UI to a running server.
## Fuseki as a Service {#fuseki-service}
@@ -69,29 +92,3 @@ directory. It is initialised the first time Fuseki runs, including a
[Apache Shiro](http://shiro.apache.org/) security file but this is only
intended as a starting point. It restricts use of the admin UI to the
local machine.
-
-## Fuseki as Configurable and Embeddable SPARQL Server {#fuseki-main}
-
-Fuseki can be run from inside an Java application to provide SPARQL
-services to application data. The application can continue to access and
-update the datasets served by the server.
-
-Basic example:
-
- Dataset ds = ...
- FusekiServer server = FusekiServer.create()
- .add("/dataset", ds)
- .build() ;
- server.start() ;
-
-See the [full documentation](fuseki-main.html) for details of
-configuration and working with data shared with the
-[Fuseki main server](fuseki-main.html) instance.
-
-## Fuseki-Server (no UI) {#fuseki-server}
-
-The artifact `org.apache.jena:jena-fuseki-server` is a packaging of
-the [Fuseki "main" server](fuseki-main.html) server that runs from
-the command line. Unlike the full Fuseki server, it is only configured
-from the command line and has no persistent work area on-disk.
-It has full SPARQL and all storage options.