Internationalized Resource Identi er (IRI) references are an inseparable part of the Semantic Web. Sometimes the references are difcult to remember, so many Resource Description Framework (RDF) serializations, e.g. Turtle, allow to shorten them. This paper describes how to nd the appropriate pre x, and resolved them to the full IRI reference. Many endpoints that provide information about pre xes and namespaces can exist in our architecture. The tools that we present are not as sensitive to failures as centralized solutions and let users use multiple pre x endpoints at the same time.
In this paper we present tools and methods that make access to pre xes more decentralized and less prone to failures. We also propose an architecture for decentralization namespace lookup services. Moreover, we introduce a serialization, which allows to de ne endpoints that are compatible with our architecture.
The paper is constructed according to sections. In Section 2 we present our architecture and serialization. In Section 3 we demonstrate our tools and discuss their user interface. The paper ends with conclusions. 2
Our architecture assumes the existence of many RESTful web services [
Web app
Console app RESTful web service
Storage
Web
In our proposed architecture, we assume the existence of many RESTful web
services [
IRI /api/prepare HTTP request
HTTP response
JSON on REST architecture. We implemented our web service in the Limonade3 microframework. This microframework o ers a number of functions that facilitate the implementation of services based on HTTP(S) protocol methods.
The key function of our tool is to modify the Turtle's documents. This operation nds pre xes that do not have declared namespaces and choose the best one. Finally, the document is displayed in the body of the response. The supported formats are Turtle, JSON-LD, N-Triples, and RDF/XML.
One of the most important functionalities of the web service is searching for namespaces for a speci c pre x. To receive data, the GET method should be used. When a client calls the web service, documents containing the speci ed pre x are retrieved from the database. If there is no namespace, the response code is 404. The default serialization is JSON-LD, but we support also Turtle. To receive Turtle data the Accept header with the text/turtle value should be used. A response return 15 items by default. The limit parameter after query string is used to change the number of displayed elements.
Our tool supports namespace declarations for Turtle, RDF/XML, RDFa, JSON-LD serializations, SPARQL query language, plain text, CSV and TSV data formats. To receive a declaration in these formats the GET method sould be used. The returned data can be in plain text or in Turtle.
Being signed in a user receive the access to perform additional operations.
For this purpose, the OAuth2 [
add a namespace, user should send a JSON-LD document by using the POST method.
The second operation requiring authentication is voting. Having a namespace, we can vote 'for' (plus) or 'against' (minus) using the POST method. In one pre x we have the possibility to add one plus and many minuses. If one make a mistake, she/he can delete the vote by using the DELETE method. If the POST method is executed successfully the response 201 code is returned, and if the resource is already exists the 409 code is returned.
Another feature of the web service is the ability to preview popular pre xes
that have the most votes. To receive that answer, a user should send GET method.
The response can be in the JSON-LD or in Turtle. It supports the pagination
using the Hydra vocabulary [
Turtled and Console Application
In this subsection we propose Turtled. It is a serialization that extends Turtle
to support many decentralized RESTful web services. We expand the Turtle
grammar to the @prefix endpoint directive, which points to various web
services that resolve pre xes. Listing 1.1 shows an extended grammar of Turtle in
EBNF.
[
j endpoint
Another independent part of our architecture is the console application, which aims to show the use of the web service (see Subsection 2.1). This console application works according to the following steps. In the rst step, the script nds the @prefix endpoint directive in the Turtle/Turtled document that contains the web service IRI references. As a result, the web service returns a response about successful or negative modi cation of the Turtle document. If the script receive a negative response, it attempt to send to the other existing web service form the second @prefix endpoint directive. 2.3
Web Application A web application is designed to support the web service (Subsection 2.1), which is designed to send HTTP requests and present data in a user-friendly form. Each webpage is described using RDFa. The application is adapted to mobile devices. The elements on the webpages have been separated so that a user can click exactly on one element in the mobile devices.
The application at the top has a menu to help you navigate the site. In the upper right corner there is the Sign in to get permission button which allows users to sign in. Being signed in, a user get permission to manage namespaces. On the main page of the site there is also a search engine that helps to nd a speci c pre x.
After entering the pre x, the middle part of the page is reloaded. Below the menu there is a header that inform about the current pre x. A user can vote for the namespace with plus or minus by clicking the appropriate button. When a user click Add alternative namespace, a text box appears and let a user to add a new namespace. At the bottom of the page there are a few data formats with current pre x and namespace.
The web application also can show the popular pre xes. The key feature of our application is the preparation of Turtled documents (see Subsection 3). 2.4
Database
The part that collects data is a database based on JSON documents and the
REST architecture [
Each occurring document in the database is an object representing a namespace. The database diagram is shown in Fig 3.
document JSON + namespace: string + prefix: string + pluses: object + minuses: object + score: int
pluses + Google: string [] + Facebook: string [] + Github: string [] + Reddit: string []
minuses + Google: string [] + Facebook: string [] + Github: string [] + Reddit: string []
document JSON + _id: string + account_id: string + expires: object + minuses: object The RESTful web service can be tested at https://prefix.chemskos.com/ api/. One of the main functionalities is nding namespaces of pre x. This operation requires GET method. Listing 1.2 shows the namespaces related to pre xes. c u r l X GET ' https : / / p r e f i x . chemskos . com/ api / f o a f ' n H ' accept : t e x t / t u r t l e '
Listing 1.2. Request in curl showing namespaces
The obtained data can be in JSON-LD or Turtle formats. If there are not any pre xes, it will be returned 404 error. Listing 1.3 shows response containing namespaces in Turtle format. @prefix p r e s : <http : / / i i . uwb . edu . p l / p r e f i x r e s o l v e r#> . [ ] <p r e s : namespaces> ( [ <p r e s : namespace> " http : / / xmlns . com/ f o a f /0.1/" ; <p r e s : score > 1 ; ] ) .
The response to access the namespace declaration is shown in Listing 1.4. The
supported formats are Turtle, RDF/XML, RDFa, JSON-LD, SPARQL, CSV,
and TSV. Additionally, we add support for a plain namespace that can be used
independently of RDF serialization. This can de ned by Well-Known URIs [
Listing 1.4. Request in curl for declaration namespace
Namespaces are added using POST method. The active access token is necessary to perform function. The request has been shown on Listing 1.5. c u r l X POST n ' https : / / p r e f i x . chemskos . com/ api / f o a f ' n H ' accept : a p p l i c a t i o n / l d+json ' n H ' A u t h o r i z a t i o n : Bearer a c c e s s token ' n d 'f " @context " : f" p r e s " : " http : / / i i . uwb . edu . p l / p r e f i x r e s o l v e r #"g, "@id " : " https : / / p r e f i x . chemskos . com/ api / f o a f " , " p r e s : namespace " : " http : / / namespace . com/ ns#" g '
Listing 1.5. Request in curl for creating a new namespace
Displaying popular pre xes can be presented in JSON-LD or Turtle serializations. The request has been shown on Listing 1.6 c u r l X GET n ' https : / / p r e f i x . chemskos . com/ api / popular ' n H ' accept : t e x t / t u r t l e ' n
Listing 1.6. Request in curl showing popular pre xes
The last functionality is submitting Turtled or Turtle documents. After modi cation the RDF le can be downloaded. Listing 1.7 shows the submission of Turtled. After transformation N-Triples is expected. c u r l X POST n ' https : / / p r e f i x . chemskos . com/ api / prepare ' n H ' accept : a p p l i c a t i o n /n t r i p l e s ' n F f i l e =@ p a t h t o f i l e . t t l
Listing 1.7. Submitting Turtled document
The source code can be found on https://github.com/KarolLitman/Dictionaryof-RDF-Pre xes-webservice.
The API documentation was created, which facilitates the understanding of the service in a readable manner. The documentation consists of queries that can be performed on the RESTful web service. Additionally, by clicking on a given method, a user obtains sample source code, structure of the query, required parameters and displaying all possible errors in the method. Swagger4 was used to create the API documentation. It can be found on https: //prefix.chemskos.com/api/doc/. The documentation shows samples of usage in various programming languages.
The web application can be viewed at https://prefix.chemskos.com/. The application at the top has a menu to help users navigate the site. The menu contains hyperlinks for the Home page, Popular page and Prepare document page. In the right corner there is the Sign in to get permission button which allows a user to sign in. In Fig. 4 the web page with found pre x is presented.
The use of the web application has been presented on the screencast and published on https://www.youtube.com/watch?v=-hSYA8epMlA. The source code can be found on https://github.com/KarolLitman/Dictionary-ofRDF-Pre xes-webapp.
The use of the console application has been presented on the screencast and published on https://www.youtube.com/watch?v=O4tjuo1BB24. The screencast shows how the application deals with broken endpoints. The source code can be found on https://github.com/KarolLitman/Dictionary-of-RDF-Pre xesbashscript.
Decentralization is the key to resilience in Internet applications. In this paper we present a DRPD architecture that are decentralized. We demonstrate four elements of our architecture: RESTful web service with documented API, web application with client-side that remote calling resources from our endpoint, console application that also use our web service, and RESTful document-oriented database. Moreover, we propose Turtled serialization that supports endpoints that are compatible with our architecture.
We have taken an initial step in easier delivery of pre xes and namespaces. In future work we would like to extend this work to other serializations that use pre xes. The next key challenge will be to provide more decentralized way of addressing the pre x endpoints e.g. using Magnet URI scheme or ni URI scheme.