This paper presents an architectural framework to build semantic resource mashups that query, process and integrate data from business objects, Linked Open Data sources and Web APIs, as semantic resources. Such resources can be queried locally or distantly in an HTTP-like manner and exchange representations as RDF graphs. We illustrate this work with an application that mashes up sensor and actuator data for the Web of Things.
The Web of services forms a graph in which nodes can produce and consume data.
Each node can be regarded as a mashup that queries other nodes, processes the data
locally and serves back enriched data. Semantic mashups are Web applications that
rely on shared vocabularies to understand and enrich RDF graphs, such as DataConf
[
In this paper, we propose an architecture integrating these two frameworks, based on the notion of Semantic Resource Mashup (SRM). SRMs are applications that can retrieve, transform and match graphs representing resources from different endpoints into a common graph representing an enriched resource. This paper is organized as follows: it presents the architecture of our framework and illustrates its use in a Web of Things application. We then conclude and draw perspectives of this work. 2
We herein propose to combine RDF-REST and the DataConf mashup engine into an
SRM framework. The framework aims at building applications that mash up
SemanticResource objects that extend Backbone Model objects so that they conform to the
RDF-REST resource interface. The architecture of an SRM (see Fig. 1) relies on the
following domain-specific elements: i) a Backbone router2 that provides to the SRM
the ability to identify the routes corresponding to each type of known resource:
depending on the hash part of the current URL, the router identifies the resource brokers
(see below) that can provide descriptions or enrich the requested resource; ii) a
resource ontology that describes the RDF types of all the resources that the application
can handle in the Hydra vocabulary [
Each time an SRM application is queried about a particular SemanticResource
instance using a particular HTTP verb, it uses its own router to determine the
appropriate Route based on the resource type and available resource broker descriptions, using
the hash part of the URI (as does Backbone’s router). It then identifies the resource
brokers that can enrich this resource and invokes them through the RDF-REST engine,
regardless of the fact that the resource broker addresses a local or distant source. The
2 In this work, we thus assume SRMs to be single-page, client-side applications.
3 https://dvcs.w3.org/hg/web-intents/raw-file/tip/spec/Overview.html
resource and the resource brokers exchange RDF graphs through RDF-REST parsers
and serializers. Each graph is mapped to the existing one using the local semantic
resource aggregator that produces the complete graph of the enriched resource.
We illustrate the applicability of our work in the domain of the Web of Things, using
the concept of “avatar”. Avatars are software artifacts that represent physical objects
on the Web, expose object high-level behaviors (aka “functionalities”) as REST
resources and collaborate with other avatars [
The avatar of the temperature sensor receives a POST request containing a graph that states that the temperature should be regulated to 22°C. The router identifies that the resource broker that handles the local TemperatureRegulator resource can handle this graph. It transmits the graph to the resource and its internal logics determine that it first needs to know the actual temperature. It sends a GET query to the local TemperatureSensor resource, which returns a graph informing that the temperature is 20°C. It then determines that the room should be heated and sends a PUT request to start the heater, which is handled by the avatar of the heater using the same architecture and returns a graph stating that the heater is on. The TemperatureRegulator resource then returns to its client a graph stating that the thermoregulation is active, using the TemperatureSensor and TemperatureHeater resources, while internally continuing to regularly send requests to the sensor and heater resources. This work is funded by the French National Agency for Research (ANR), under the reference <ANR-13-INFR-012>. 4
In this paper, we present an architecture for Semantic Resource Mashups that relies on the RDF-REST and Backbone.js frameworks to process distributed RESTful resources. It mainly relies on: i) semantic resources that exchange RDF representations of business objects and expose uniform HTTP-compliant interfaces, ii) a resource ontology that describes the domain resource types and relations and iii) an RDF-based engine for routing and aggregating data flows. We illustrate our approach with a temperature regulation example for the Web of Things.
SRMs can be used to query RESTful endpoints such as RDF stores or to build a
network of collaborative nodes. They also enable adaptive resource deployment on the
server or client side without changing the application-level interactions between
objects. Future work includes enabling SRMs to create, update, delete locally enriched
resources, while being able to propagate these changes to appropriate endpoints.
Another perspective is to replace the currently static broker descriptions and aggregation
rules with dynamic discovery infrastructures such as RESTdesc [