Can XtreemStore group objects
using your own metadata?

Yes. XtreemStore has a native capability called objectGrouping that routes inbound objects into containers based on user-supplied S3 metadata. When an object is uploaded with a custom metadata header, XtreemStore reads the tag value and automatically places that object into the matching container — no post-processing required.

The metadata tag can come from any source — your own database, a DAM, a MAM, or any system that knows what a file is. If you don't already have a way to capture and query embedded metadata from your storage, GRAU DATA's MetadataHub can provide that catalog layer.

Tags are attached as standard S3 user-defined object metadata using the x-amz-meta- prefix in the request header at upload time. No special XtreemStore SDK or API is needed — any S3-compatible client works.

For example, to tag an object with group=project-alpha:

# MinIO Clientmc cp --attr "group=project-alpha" myfile.mxf s3xts/mybucket# AWS CLIaws s3api put-object \  --bucket mybucket \  --key myfile.mxf \  --body myfile.mxf \  --metadata '{"group": "project-alpha"}'

Any S3 PUT that includes the right x-amz-meta-<key> header will be routed by XtreemStore automatically. The key must match what is defined in the tenant's objectGrouping rule; the value is whatever the user or application supplies.

A container is XtreemStore's internal packaging unit — conceptually similar to a tar archive. Multiple objects that share the same grouping attribute are collected into a single container, which is then written to tape as one cohesive unit.

Containers are closed (sealed) based on configurable thresholds — either by total size or by elapsed time — and once closed, no new objects are added. All objects in a container are always written and recalled together, which is ideal for tape efficiency.

The objectGrouping rule is configured by an XtreemStore administrator at the tenant (S3 bucket) level. The admin declares which metadata key drives the grouping. The key is defined with an empty value — XTS uses the key to determine whether grouping should occur, and the value is supplied by the S3 client at PUT time.

Example tenant rule using a metadata key called group:

// Tenant configuration excerpt{  "objectGrouping": {    "group": ""  }}

With this rule active, XTS looks for an x-amz-meta-group header on every incoming PUT. When it finds one, it uses the header's value to assign the object to the matching container. Objects carrying group=project-alpha land together; objects carrying group=project-beta land in a separate container.

Yes — any metadata system works. XtreemStore's grouping mechanism operates entirely at the S3 PUT layer. It reads a tag you supply on each object and groups accordingly. It has no dependency on where that tag came from — your own database, a DAM, a MAM, a spreadsheet, or MetadataHub all work identically.

The workflow is the same regardless of your metadata source: query your catalog to identify a group of files, decide what tag value represents that group, move the files to XtreemStore with that tag on every S3 PUT, and XtreemStore handles the rest.

Files in a group can come from any combination of source storage systems. XtreemStore doesn't see or care about the source — it only reads the tag on the S3 PUT and groups accordingly. On recall, the entire container is retrieved in a single tape operation.

Two configurable rules govern container lifecycle, set independently per tenant:

closeContainerBySpace — seals a container when it reaches a defined size threshold (in bytes) or object count. Example: seal after 1 GB or 200 objects, whichever comes first.

closeContainerByTime — seals a container after it has been open for a defined period (in seconds), even if it hasn't hit the size threshold. This prevents objects from waiting indefinitely in open containers.

"closeContainerBySpace": {  "OR": [    { "CONTAINER_OBJECTS": 200 },    { "CONTAINER_SIZE": 1000000000 }  // 1 GB  ]},"closeContainerByTime": {  "CONTAINER_AGE": 60  // 60 seconds}

Once sealed, the container is queued for tape. The isSafelyStored rule then governs when the buffer copy can be released — typically after confirmed write to one or more tape pools.

Yes. The objectGrouping rule is configured per tenant, and each tenant is presented to users as an S3 bucket. This means you can have:

• A media assets bucket grouped by project
• A raw footage bucket grouped by shoot_date
• A client deliverables bucket grouped by client_id

Each bucket operates independently with its own grouping logic, container thresholds, and storage targets. Users interact with them as standard S3 buckets — XtreemStore handles the tape-layer logic transparently.

XtreemStore will accept the file and write it to tape — it will not be rejected. However, because it carries no grouping tag, the objectGrouping rule has nothing to act on. The file will be assigned to its own ungrouped container, separate from any metadata-defined group.

The XTS documentation is explicit: each object uploaded to a bucket with an active objectGrouping rule must include the x-amz-meta-<key> header for grouping to take effect. Without it, the object is stored but not grouped.

Yes — manual moves using any S3-compatible client are fully supported. XtreemStore's S3 Frontend accepts standard S3 PUT requests regardless of what client issues them. The grouping tag is simply passed as a metadata header on the PUT, the same way any S3 user-defined metadata is applied.

Both the AWS CLI and MinIO Client work directly:

# AWS CLI — manual single file move with group tagaws s3api put-object \  --bucket mybucket \  --profile xts \  --key "footage/clip_001.mxf" \  --body /source/footage/clip_001.mxf \  --metadata '{"group": "project-alpha"}'# MinIO Client — manual single file move with group tagmc cp --attr "group=project-alpha" \  /source/footage/clip_001.mxf \  xts/mybucket/footage/clip_001.mxf

The only requirement is that every file in the group carries the same tag value. Whether files are moved one at a time manually or in bulk via a data mover, XtreemStore sees the tag and groups them identically.