Workflow
This page describes how a container moves through the platform — from sign-in to publication. Each part below is broken down into its own detailed workflow.
Overall Workflow
A container moves through the platform in seven parts, from sign-in to viewing and sharing. Each part is a hyperlink below — click a part to jump to its detailed workflow.
Sign in, artifacts and resources, execution environment, container metadata, and sealing happen inside the creation wizard; publishing and viewing happen after the container is sealed. Each part is handled by the components listed in its detail section (see Architecture for the component inventory).
Detailed Workflows
Sign in
Components involved: rdmc_auth, rdmc_configuration, rdmc
flowchart TB
A["Login request"] --> B["Redirect to external<br/>identity provider"]
B --> C{"Authentication<br/>successful?"}
C -- no --> B2["Error shown,<br/>back to landing page"]
C -- yes --> D["Session created"]
D --> E{"Configured<br/>RDMC creation<br/>URL?"}
E -- yes --> F["Configured RDMC<br/>creation workflow"]
E -- no --> G["Default configuration<br/>applied<br/>Default Workflow"]
F --> H["Start of Creation<br/>Workflow"]
G --> H
The user signs in through the external identity provider; a failed authentication returns to the landing page with an error. After a successful login, the session is created. If a configured RDMC creation URL is set, the user continues with the configured RDMC creation workflow; otherwise, the default configuration applies and the user follows the Default Workflow. Both paths lead to the Start of the Creation Workflow. Every later part re-checks this session and these permissions.
Create artifacts & upload resources
Components involved: rdmc
flowchart TB
A{"New container or<br/>continue existing?"} -- new --> B["Create container<br/>(title)"]
A -- continue --> B2["Load saved state<br/>from Dashboard"]
B --> C["Create artifact<br/>(name, access level:<br/>public / restricted / private)"]
B2 --> C
C --> D{"Resource type?"}
D -- file --> E["Upload file"]
D -- folder --> F["Upload folder<br/>(structure validated)"]
D -- link --> G["Add repository link<br/>(platform detected)"]
E --> H{"Upload valid?"}
F --> H
G --> H
H -- no --> H2["Error shown,<br/>fix and retry"] --> D
H -- yes --> I{"More<br/>resources?"}
I -- yes --> D
I -- no --> J["Describe artifact(s)"]
J --> K["Artifact Summary"]
K --> L{"More<br/>artifacts?"}
L -- yes --> C
L -- no --> M["Continue to Execution environment"]
A container is either created fresh (with a title) or resumed from the Dashboard — all progress is persisted between sessions. Each artifact gets an access level that later controls who may see its content. Resources can be files, folders, or repository links; every upload is validated (file type, folder structure, link platform) and rejected uploads are reported back for correction. An artifact is complete only when its required questions are answered; this whole part repeats per artifact.
Resource types
Every uploaded resource is tagged with one or more built-in types (plus optional custom types from configuration):
Data — general research data assets (datasets, tables, measurements, or supporting files).
Software — general software engineering artifacts (source code, scripts, libraries, tools, or executables).
RDMC — intended to connect a previously created Research Data Management Container (RDMC) to the current container.
RDMC + REE — intended to connect a previously created RDMC that includes a Reusable Execution Environment (REE) to the current container.
Note
In the backend, RDMC and RDMC + REE map to RDMCUpload (UploadKind.RDMC in rdmc/models.py) and are written into manifest.rdmc, but neither type currently performs any active backend linking or processing.
Execution environment
Components involved: ree_service, rdmc
flowchart TB
A{"Feature enabled in<br/>configuration?"} -- no --> A2["Notice shown,<br/>continue to Container metadata"]
A -- yes --> B{"Environment already<br/>linked to container?"}
B -- yes --> C["Workbench reopens<br/>existing environment"]
B -- no --> D["Create named environment<br/>on REE service"]
D --> C
C --> E{"Fill a component slot:<br/>repository / runtime / SBOM"}
E -- pick from container --> F["Stream selected resource<br/>to REE service"]
E -- upload from device --> G["Store as container resource,<br/>then stream to REE service"]
F --> H{"File type accepted<br/>by REE service?"}
G --> H
H -- no --> H2["REE error shown<br/>as-is"] --> E
H -- yes --> I{"Required slots filled<br/>for a job?"}
I -- no --> E
I -- yes --> J["Run job:<br/>export / build / validate"]
J --> K{"Job finished<br/>successfully?"}
K -- no --> K2["Inspect job log,<br/>fix components"] --> E
K -- yes --> L["Download artifact or<br/>save it into an artifact folder"]
L --> M{"More jobs?"}
M -- yes --> J
M -- no --> N["Continue to Container metadata"]
The workbench first checks the feature flag; when disabled, it only shows a notice. A container keeps a one-to-one link to its environment, so returning users get their existing environment back instead of a new one. Component slots are filled by picking container resources or uploading from the device (device uploads also become container resources); the REE service enforces the accepted file types, and its error messages are surfaced unchanged. Jobs are ready to run once their required slots are filled; failed jobs are diagnosed through their logs, and successful results can be saved back into a chosen artifact folder, where they count as regular resources of the sealed container.
Container metadata
Components involved: rdmc, rdmc_metadata
flowchart TB
A["Latest metadata question schema<br/>(active configuration & version)"] --> B{"Existing<br/>manifest file (.rdmc)?"}
B -- yes --> C["Load manifest file<br/>and auto-fill schema fields"] --> D["Save metadata"]
B -- no --> E["Fill schema form manually"] --> D
D --> F["Metadata editable<br/>until sealing/signing"]
F --> G["Continue to Seal & sign"]
The metadata form displays the latest version of the question schema (active configuration and version). If the user has an existing RDMC manifest file (.rdmc), it is loaded and the schema fields are automatically filled; otherwise, the user fills the schema form manually. In both cases, the metadata is saved. The metadata stays editable — returning to this part regenerates and revalidates it — until sealing/signing.
Seal & sign
Components involved: rdmc, rdmc_sign
flowchart TB
A["Final review page:<br/>artifacts, resources,<br/>metadata summary"] --> B{"Everything complete?<br/>(manifest valid,<br/>required answers given)"}
B -- no --> B2["Back to the<br/>affected part"]
B -- yes --> C{"Acknowledgment<br/>confirmed?"}
C -- no --> A
C -- yes --> D["Content hash computed<br/>for every file"]
D --> E["Hashes written<br/>into the manifest"]
E --> F{"Signing service<br/>reachable?"}
F -- "no (offline)" --> G["Sealed without certificate,<br/>creation method records<br/>offline sealing"]
F -- yes --> H["Container signed"]
G --> I["Container sealed"]
H --> I
I --> J{"Review workflow<br/>configured?"}
J -- yes --> K["Evaluation report<br/>generated from<br/>sealed state"]
J -- no --> L["Continue to Publish"]
K --> L
Sealing is guarded twice: the summary must be complete (valid manifest, all required answers), and the owner must confirm the acknowledgment text. Then every file’s content hash is computed and recorded in the manifest. Signing depends on the environment — when the signing service is unreachable (e.g., a local installation without internet access), the container is still sealed, and the creation method records that it was sealed offline. A sealed container is immutable: it can only be viewed, reviewed, published, and shared. Where a review workflow is configured, evaluation reports are generated from the sealed state.
Publish
Components involved: rdmc_publish, search_portal
flowchart TB
A{"Container<br/>sealed?"} -- no --> A2["Publishing unavailable<br/>until sealed"]
A -- yes --> B["Choose target repository:<br/>Zenodo / Dataverse / Coscine"]
B --> C{"Already published on<br/>another platform?"}
C -- "yes, record still exists" --> C2["Publication blocked,<br/>conflict shown"]
C -- no --> E{"Authorization for the<br/>platform available?"}
E -- no --> F["Authorize"] --> E
E -- yes --> G["Upload container files<br/>& metadata"]
G --> H{"Upload<br/>successful?"}
H -- no --> H2["Error reported,<br/>status kept, retry possible"] --> B
H -- yes --> I["Publication record stored<br/>(platform, identifier, status)"]
I --> J["Persistent identifier<br/>updated"]
J --> K{"Search portal<br/>registration enabled?"}
K -- yes --> L["Container registered<br/>in search portal"]
K -- no --> M["Done -- container<br/>published"]
L --> M
Publishing is only available for sealed containers. The policy check enforces a single publication platform per container: a conflicting publication blocks the attempt, unless the remote record no longer exists, in which case the stale record is cleaned up. The user must be authorized with the chosen platform before uploading. Failed uploads keep their status and can be retried; successful ones store a publication record, update the persistent identifier, and — when enabled — register the container with the central search portal so it becomes findable.
View & share
Components involved: viewer, rdmc
flowchart TB
A["Visitor opens container<br/>(share link or<br/>search result)"] --> B{"Who is the<br/>visitor?"}
B -- owner --> C["Full access:<br/>public, restricted<br/>& private artifacts"]
B -- reviewer --> D["Full access for review<br/>(access banner shown)"]
B -- "public / anonymous" --> E["Public artifacts only"]
C --> F{"Per artifact:<br/>access level allows<br/>viewing?"}
D --> F
E --> F
F -- no --> G["Artifact hidden /<br/>content not shown"]
F -- yes --> H["Artifact listed<br/>in file tree"]
H --> I["Explore files,<br/>metadata & manifest"]
I --> J{"Owner viewing?"}
J -- yes --> K["Switch perspective:<br/>preview as reviewer<br/>or public"] --> B
J -- no --> L["Read-only browsing<br/>(no modifications)"]
Visitors reach the viewer through a share link or a search result. Their role determines the scope: owners and reviewers see all access levels (reviewers with an access banner); anonymous visitors see only public artifacts. On top of the role, each artifact’s own access level determines whether its content is shown or hidden. Owners can additionally switch their perspective to preview the container exactly as a reviewer or an anonymous visitor would see it. All viewing is strictly read-only.
Full Activity Diagram
For reference, the complete activity diagram covering the whole process in a single picture:
Show the full activity diagram
Figure: Activity diagram for the process to create and seal the container