This walkthrough is a click-by-click guide for understanding the full simulator flow.
Run:
docker compose up -d --buildOpen http://localhost:4000.
Goal: one node publishes, another node searches and requests.
Example:
- Provider:
NordBeton AG - Consumer:
Stahlwerk Weber
What to do:
- Use
NordBeton AGas the provider node (this node will publish). - Use
Stahlwerk Weberas the consumer node (this node will search/request). - Click a node to open its panel, then switch to the other node when needed.
- Confirm both nodes are snapped to the dataspace ring (connected position).
What happens technically:
- Node data and claims are loaded from backend (
/api/nodes).
Goal: create a dataset with metadata and policy.
What to click:
- Click
NordBeton AG. - In the connector panel, open data storage and click
Publish Asset. - Upload a file (
.json,.csv, or.txt). - Fill
Titleand optionalDescription. - Select policy (for first test, choose
Open). - Optionally add DCAT metadata fields (keyword/theme/spatial/etc.).
- Click
Publish Asset.
What happens technically:
- Backend stores asset + payload in SQLite.
- Backend indexes semantic metadata in Fuseki as RDF/DCAT.
Goal: understand provider discovery and catalog access.
What to click:
- Click
Stahlwerk Weber. - Open
Browse Dataspace. - In
Browsetab, clickSearch. - Click
View Catalogfor a provider.
What you see:
- Discovery/control-plane animations.
- Provider catalog assets in the panel.
What happens technically:
- Frontend requests policy-filtered catalog from backend.
- Backend filters visibility using consumer claims.
Goal: see catalog-first semantic behavior.
What to click:
- Stay in
Browse Dataspace. - Switch to
Semantic Searchtab. - Enter search text (example:
boat) and clickGo. - Optional: add field filters (DCAT key + value), then
Go.
What you see:
- Live status text phases (discovering/collecting/querying/preparing).
- Result cards with title, description, metadata.
What happens technically:
- Backend first computes policy-visible assets.
- Backend passes only visible dataset IDs into SPARQL filter.
- SPARQL ranks/refines only within allowed IDs.
Goal: contract + transfer from semantic result card.
What to click:
- In a semantic result card, click
Request Contract.
What you see:
- Negotiation animation (control plane).
- Contract phase status.
- Automatic transfer phase.
What happens technically:
- Backend creates negotiation and advances states.
- On agreement, transfer is initiated.
- Asset payload is copied to consumer received storage.
What to click:
- Close popup if needed.
- In
Stahlwerk Weberconnector, open data storage. - Check received asset entry.
What to verify:
- Asset appears as received.
- Source/provider is shown.
- Metadata is visible.
Goal: show governance effect.
What to click:
- Publish a new asset on provider with restrictive policy (industry/role/DID group).
- Run semantic search as consumer without matching claims.
Expected outcome:
- Asset not visible in catalog or semantic results, or negotiation denied.
What happens technically:
- Same policy model is applied to catalog visibility and negotiation enforcement.
- Publish one open asset on provider.
- From consumer, run semantic search and show result.
- Click
Request Contractand show auto transfer. - Show received asset at consumer.
- Publish second asset with restrictive policy.
- Show that it is filtered/denied.
-
No semantic results:
- Ensure asset is published and description/title contains search term.
- Ensure policy allows consumer visibility.
- Check active field filters in semantic UI.
-
Search works but no result card for expected asset:
- Confirm provider is not the same active consumer node.
- Confirm node is connected in ring.
-
Transfer does not appear:
- Check negotiation status in UI.
- Check backend logs (
docker compose logs -f sim-backend).
- Overview:
simulator/README.md - Presentation narrative:
simulator/PRESENTATION.md - Technical details:
simulator/DOCUMENTATION.md