RUN-DSP is a lightweight, high-performant, and easy to manage connector for the IDSA Dataspace protocol implemented in the Go programming language. What distinguishes RUN-DSP from other dataspace connectors is that RUN-DSP tried to stay simple to maintain and manage, while allowing non-dataspace-aware applications to interface with a dataspace by means of gRPC.

RUN-DSP listens for dataspace requests, and queries a provider backend for the relevant information via gRPC calls. This information can be catalog listings, information about a single dataset, and information on how to download the dataset. In dataspace parlance, this would mean RUN-DSP fulfils the provider role.

RUN-DSP can also listen on a port for gRPC control commands, that another application can use to request dataspace operations to be executed by gRPC. The consumer role in dataspace terms. This functionality still requires that the dataspace port is reachable publicly.

As per the dataspace specification, it is possible for RUN-DSP to fulfil the consumer, and provider side from a single installation if properly configured.

You can find how to setup a simple demo dataspace in the dev-dataspace directory.

To start developing on RUN-DSP itself, you can set up a basic setup like this:

First start up the "dataspace" with docker-compose:

$ docker-compose up

Then start RUN-DSP connecting to the reference provider:

$ go run ./cmd/ -c ./conf/localdev.toml server

You can now start hacking and testing RUN-DSP.

The dev-dataspace demo setup can also be used to test and debug RUN-DSP.

To start integrating your own application, and/or data into a dataspace using RUN-DSP, you will have to offer the RUN-DSP provider service gRPC calls. This can either be integrated into your already existing software, or you can build a translation service that translates the gRPC calls into calls that your application already accepts.

Once your provider service supports all the endpoints, all you need to do is set the right configuration, all provider configuration settings are documented in the [server.provider] section of the reference configuration file.

We offer a reference provider that can be used as an example of how to implement the provider service.

RUN-DSP offers gRPC calls to allow an application to easily interact with other dataspace participants. The RUN-DSP client uses these to implement a basic dataspace client. The control service can be configured using the [server.control] section of the configuration file.

We welcome code contributions, but as RUN-DSP is being rapidly developed, it might be wise to open an issue first to discuss any proposed issues.