All Classes and Interfaces
Class
Description
AbstractEntitySchemaManagement<E extends org.gcube.informationsystem.types.reference.entities.EntitySchema>
AbstractRelationSchemaManagement<T extends AbstractEntitySchemaManagement<TT>,TT extends org.gcube.informationsystem.types.reference.entities.EntitySchema>
Read-only public REST facade under
/access, mirroring the read endpoints of
ContextManager, TypeManager, InstancesManager and
QueryTemplateManager for callers that only need query/read access.This SystemEnvironment is used in all the cases where the
operation must be done by an administrator.
Global Privileged raw-query diagnostics.
Global Privileged whole-system operations (System Dump, System Restore).
Base class for JAX-RS REST resources, providing common logger, context injection,
and response-building utility methods.
Implements the C3 linearization (Method Resolution Order) merge step used to
deterministically order a Type's ancestors under multiple inheritance.
CachedType<T extends org.gcube.informationsystem.types.reference.Type>
Represents a cached representation of a metadata schema type, providing
high-performance schema lookup and type hierarchy traversal.
Readiness of the cache (Redis): the service is degraded when the cache is not reachable, since
the caches and the cluster events fall back to the database and every operation still runs.
Security partition acting as a cemetery/archive for deleted Contexts: a Context vertex is
never actually removed from the database on delete, but moved into this partition (its record-level
security roles switched from
ContextEnvironment's live partition to this one), preserving
it as historical information.Internal service relation representing a child-to-parent context edge.
One immutable notification broadcast over the
ClusterEventBus.Broadcasts
ClusterEvents to every service instance in the deployment, and delivers
received ones to locally registered consumers.The kinds of event broadcast across service instances over the
ClusterEventBus.Defines OrientDB comparison and collection operators used in JSON queries.
Recognizes the failure of a write that lost the race with another write: the backend reports
it with an
ONeedRetryException when both changed the same records, and with a
duplicate key (see DuplicateKeyDetector) when both wrote the same value of a unique
index (e.g. the same id), which the checks of the service, made before the other write
committed, could not see.The
connectivity group of the public statistics: how the Resources are connected, from a
scan of every instance, every 6 hours.Manages the ConsistsOfSchema relation type definition in the database schema.
Global JAX-RS response filter emitting
Content-Location (RFC 9110 Section 8.7), per
07-api-foundations-and-roles.md: "the canonical URI of the returned payload, or the
specific URI that generated a failure in error responses" - for creation/update responses,
single-instance reads, and error responses alike.Structured representation of a single
X-Warning header entry related to one
content field in the response body.Warning flavour.
Encapsulates the outcome of a Context creation request, decoupling the persistence
logic from REST interface HTTP status codes.
Parent context-partition environment used only to aggregate hierarchical
context roles.
OrientDB-only persistence layer for
Context entities.Policy Enforcement Point (PEP) for the
Context collection.Single data-access layer for
Context entities that coordinates
the Redis cache and the OrientDB database.Projection settings computed by the caller (typically the PEP).
The
contexts group of the public statistics: the Context tree.Stores the authoritative version of the persisted Context topology.
Static, class-loading-time bootstrap of the OrientDB connection and, on a genuinely fresh
database, of the whole security-partition and type-schema layout.
Readiness of the database: the service is down when the database does not answer, since no
operation can run without it.
Contract for executing read-only database queries against the backend storage.
Resolves the domain a Type definition declares for the property addressed by a query path.
The labels of each depth of the Context tree in the public statistics, as configured in the
database of the registry (
StatisticsConfigurationStore): the long one where Contexts are
counted by depth, the short one where a value is given per depth.Average, median and maximum of a set of counts, as the public statistics show them.
Recognizes the failure of a commit refused by a unique index: a record carrying a key that
another record already holds, reported by the backend with an
ORecordDuplicatedException,
which the layers above may have wrapped.Carries a serialized element and the atomic outcome of a persistence upsert.
ElementManagement<El extends com.orientechnologies.orient.core.record.OElement,T extends org.gcube.informationsystem.types.reference.Type>
Common OrientDB persistence base class for every managed element category (Context, Type,
and Instance — Entity/Relation alike): CRUD orchestration (create/read/update/delete,
paginated list, existence check), JSON <-> OrientDB property mapping, schema/UUID
consistency checks, and metadata handling (autofill vs
ElementManagement.preservePassedMetadata,
privacy masking).Static helpers shared by the OrientDB
*Management classes: UUID-based element
lookup (vertex or edge, admin or session-scoped), binding a raw OVertex/OEdge
to the appropriate EntityManagement/RelationManagement subclass based on its
schema type, and low-level OElement/JsonNode conversion utilities.The EncryptedOrient class extends ODocument and implements the Encrypted interface.
EntityElementManagement<E extends org.gcube.informationsystem.base.reference.entities.EntityElement,ET extends org.gcube.informationsystem.types.reference.entities.EntitySchema>
EntityManagement<E extends org.gcube.informationsystem.model.reference.entities.Entity,ET extends org.gcube.informationsystem.types.reference.entities.EntitySchema>
Base OrientDB persistence class for the two Entity categories,
Resource and
Facet (see the concrete ResourceManagement and FacetManagement
subclasses).Manages the type-definition record of
Entity itself, the organizational level of the
model that Resource and Facet both extend and from which they inherit the
structural fields every instance carries.Defines database transaction permission level modes (Reader or Writer).
Defines OrientDB security artifact categories (Role or User).
Contract shared by the OrientDB persistence classes for both Entity Relationship
categories — Entities (
Resource/Facet, via EntityManagement) and
Relations (ConsistsOf/IsRelatedTo, via RelationManagement).The descendant Contexts a hierarchy synchronization aligns to the submitted Resource.
The outcome of a hierarchy synchronization.
Manages the FacetSchema definition in the database schema.
Abstract base for all
HierarchicalEnvironment subclasses that store Context vertices
(live or deleted).The fields of a submitted instance that a write dropped because its category does not accept
them, collected by the persistence layer and reported by the caller (e.g. as an
X-Warning).Structured representation of an
X-Warning header entry reporting JSON fields
present in a write request body that were ignored by the target write operation, either
because they are not recognized by the model or because they are system-managed.The general information of the registry, served without a token: the path is an
excludes entry of application.yaml, so no request handler of SmartGears runs and
there is no caller to authorize.Carries the representation and atomic creation outcome of an instance PUT operation.
Server-side registry and resolution hub for
InstanceEnvironment objects.Executes a JSON Query-By-Example against the Instances collection, enforcing role-based
and context-scoped security rules.
Policy Enforcement Point (PEP) for the Instances collection.
The
instances group of the public statistics: a scan of every instance, every 6 hours.Computes the
instances and connectivity groups of the public statistics in one
pass over every instance, through the administrative connection.Owns the explicit, order-dependent bootstrap sequence for the small set of
information-system-model-intrinsic types that must exist before the general classpath
Discovery pass can run — because later infrastructure types embed them as a nested property
type or declare them as a superclass before their own schema can be registered — plus the
shared logic to determine which Type names are is-model-intrinsic at all.Manages the IsRelatedToSchema relation type definition in the database schema.
Translates a JSON Query-By-Example payload into the equivalent SQL/MATCH query text.
Translates a JSON query subtree representing a ConsistsOf relation.
Translates a JSON query subtree representing a
Context entity.Base class translating a JSON query subtree into an SQL/MATCH fragment.
Abstract base class for translating a JSON query subtree representing an Entity.
Translates a JSON query subtree representing an entity Type definition
(
ResourceSchema or FacetSchema).Base class for JSON query elements that participate in graph relation traversal
(Resources, Facets,
IsRelatedTo, ConsistsOf), adding an edge
direction and back-reference traverseBack on top of the generic
JsonQueryElement translation machinery.Translates a JSON query subtree representing a Facet entity.
Translates a JSON query subtree representing an IsRelatedTo relation.
Translates a JSON query subtree representing a
PropertySchema definition.Translates a JSON query subtree representing a
QueryTemplate entity.Abstract base class for translating a JSON query subtree representing a Relation.
Translates a JSON query subtree representing a relation Type definition
(
IsRelatedToSchema or ConsistsOfSchema).Translates a JSON query subtree representing a Resource entity.
Formats
LinkRelation entries accumulated by a PEP into RFC 8288 Link
response headers.A single RFC 8288
Link header relation accumulated by a PEP for the current request.Global JAX-RS response filter that automatically extracts accumulated
LinkRelation
entries from the current JAX-RS ContainerRequestContext properties and emits them as
RFC 8288 Link response headers.Security partition for live Context vertices, i.e.
Defines logical operators used to connect conditions in JSON queries.
Resolves the SQL operand of a field named among the values of a mathematics operator.
The view of Context memberships a request is entitled to: it builds every
contexts
map of the response from the memberships of an instance.Resolves the models of the registry besides
information-system-model: the single place
where they are decided, wherever RegistryMetadata is (re)computed.Centralized, static, thread-safe registry of OrientDB connection pools, uniquely indexed
by connection username (e.g.
Declares the base OpenAPI document metadata (info, license, servers, and the
bearerAuth
security scheme/requirement) picked up by the SmallRye OpenAPI Maven plugin at build time.Programmatic OpenAPI filter that scans classes for custom
QUERY methods and dynamically
generates their standard POST fallback endpoints in the resulting OpenAPI specification.Validates the operand of every JSON query operator against its formal schema.
Identifies the kind of action a persistence-layer management class is currently
performing on an element (Context, Type, or Instance), independently of which
concrete class or collection is involved.
Callback hook for validating an in-progress write operation against the full set of
instances it affects, once that set is fully known (e.g. after an Avalanche Effect
propagation has resolved every instance touched by a create/update/delete).
Executes admin raw queries against the OrientDB backend.
The targets reached by a dropped
cascadeWhenOrphan relation while an instance is
removed from one Context.Carries a single page of serialized JSON results together with the
pagination context needed by the REST layer to emit
Link headers.Base class for all Policy Enforcement Points (PEP) in the resource-registry service.
Specification for an entire HTTP endpoint's policy.
Specification for query parameter authorization and validation.
Defines rules for binding the Context in the caller's JWT token to the target resource.
Emits the
Preference-Applied header for the honored OperationReturn
preference of an Operation Envelope response.Global JAX-RS response filter that automatically extracts the accumulated
OperationReturn preference from the current JAX-RS ContainerRequestContext
properties and emits it as the Preference-Applied response header.Serializes the values projected by an
_emit or a computing operator as a read does.The domain a Type definition declares for the property compared by a predicate.
The shape of a declared property.
The property naming rule of the IS-Model: the one grammar a property name follows, whether a
Type definition declares it or an instance payload carries it as a custom field.
Global JAX-RS request filter providing the
POST compatibility fallback for the
RFC 10008 QUERY HTTP method: network intermediaries (WAFs, proxies) or client
libraries that block non-standard HTTP methods can send POST {path}/query carrying
the X-HTTP-Method-Override: QUERY header instead of a native QUERY {path}.Structured representation of a single
X-Warning header entry related to one
or more query parameters.Warning flavour.
Encapsulates the outcome of a Query Template create-or-update request, decoupling
the persistence logic from REST interface HTTP status codes.
Validates a Query Template definition against the closed definition and
TemplateVariable
contract, and applies its variables: the substitution of defaults at save time and of the
supplied values at execution time.Values resolved for one execution of a Query Template.
Policy Enforcement Point (PEP) for the
QueryTemplate collection.Single data-access layer for
QueryTemplate entities.Result payload and shape produced by a Query Template JSON query.
The
queryTemplates group of the public statistics.Classifies the difference between a persisted and a submitted Query Template definition and
derives the minimum
version advancement it requires: the Version Advancement rules of
PUT /query-templates/{name}.The version advancements, by increasing reach.
Singleton manager for the Lettuce Redis connection.
Redis-backed context cache for stateless multi-instance deployments.
Provider interface for warm up tasks.
Central registry of Redis key constants and factory methods for the Resource Registry.
Redis-backed type cache for stateless multi-instance deployments.
One type as written by
RedisTypeCache.saveAll(List, long).Renders the live-registry documentation product distinct from the committed static docs (see
the Architectural Decisions Log, "Two distinct documentation products"): the is-model bucket
still comes from the classpath, since
is-model is compile-time and never
runtime-mutable, but the domain-model bucket comes from a SchemaSnapshot via
SchemaSnapshotTypesDiscoverer, so a runtime-registered type is included exactly like a
classpath-declared one.The general information of the registry, the document of
GET /info: what a client needs
to talk to it (the format of the dates, the page limits, the values of the fixed parameters), the
service and its models, and the labels of the levels of the Context tree.Computes the
RegistryMetadata the classpath defines: is-model and the domain model with
the types installed from the classpath, an empty runtime model, and no revision.Reads and persists the
RegistryMetadata singleton, stored as a document of a plain
OrientDB class of its own (no superclass).Reads and changes the
RegistryMetadata singleton at runtime, each operation in a session
of its own, with the Type environment's users: whoever works on types reads the schema version
with them.RelationElementManagement<SEM extends EntityElementManagement<? extends org.gcube.informationsystem.base.reference.entities.EntityElement,SET>,TEM extends EntityElementManagement<? extends org.gcube.informationsystem.base.reference.entities.EntityElement,TET>,SET extends org.gcube.informationsystem.types.reference.entities.EntitySchema,TET extends org.gcube.informationsystem.types.reference.entities.EntitySchema>
RelationManagement<T extends EntityManagement<? extends org.gcube.informationsystem.model.reference.entities.Entity,TET>,TET extends org.gcube.informationsystem.types.reference.entities.EntitySchema>
Manages the type-definition record of
Relation itself, the organizational level of the
model that IsRelatedTo and ConsistsOf both extend and from which they inherit
the structural fields every instance carries.Configures the JAX-RS application for the Resource Registry service.
Global JAX-RS
ExceptionMapper that maps every ResourceRegistryException
thrown by the service into an HTTP error Response.Manages the application initialization and shutdown lifecycle per execution context.
Emits a single
X-Result-Scope header combining all accumulated ResultScope
tokens as a comma-separated list, in canonical (enum declaration) order.Global JAX-RS filter that emits the accumulated
ResultScope tokens as a single combined
X-Result-Scope response header.Creates the indexes the service's lookups rely on, idempotently: bootstrap creates them on a new
database, the migration on an existing one.
Keeps everything derived from the Type schema up to date, in the background.
An immutable, version-stamped view of every Type registered in the system, loaded once and shared
by everything derived from it.
TypesDiscoverer backed by an already-loaded SchemaSnapshot: discovers types by
filtering its flat SchemaSnapshot.getTypes() by Type.getAccessType(), in-process
and with no additional I/O.The schema version: a monotonic counter, persisted as
RegistryMetadata.revisionCount,
that advances every time the Type schema is written.Common contract for all structured
X-Warning entries emitted by the
resource-registry service.The configuration of the public statistics, one record of the class
"StatisticsConfiguration" in the database of the registry, read at every computation so that
a change shows at the next one, with no restart: today the label of each depth of the Context
tree, in a long form ("depthLabels", depth → label) and a short one
("depthShortLabels").
OrientDB-specific System Dump reads: unrestricted traversal of every
Context,
QueryTemplate, Resource, and IsRelatedTo relation, serialized with
the complete state required for backup purposes.Policy Enforcement Point for whole-system administrative operations (System Dump,
System Restore).
Orchestrates database-agnostic System Dump and Restore operations for the complete logical
Resource Registry state.
Indicates that a System Restore archive is malformed or incompatible with the target.
OrientDB-specific System Restore writes.
Carries the raw JSON array produced by executing a Query Template together with the
facts about the execution that the caller (
QueryTemplatePolicyEnforcementPoint)
cannot otherwise observe: whether the template's query was projection-based (contained an
_emit block), and which supplied keys declare no variable.The single resolution of the caller's token path to a live Context, done once per request
(reference
08, Token path resolution): the token path is matched against current
paths first and then against previousPaths.Encapsulates the outcome of a Type creation request, decoupling the persistence
logic from REST interface HTTP status codes.
Interface defining accessors for managing Type names.
Security partition for all registered Type schema definitions: the core
information-system-model types, any classpath-discovered extension model
(e.g.Management and persistence layer for schemas and types definitions (Resource, Service, Facet, Property, Relation).
Policy Enforcement Point (PEP) for the Schema
Type collection.Executes a JSON Query-By-Example against the Types collection (schema definitions).
Orchestrator and repository layer for managing resource and facet Schema Types.
Result payload and shape produced by a Type JSON query.
The
types group of the public statistics: the schema and the models
RegistryMetadata lists.Global JAX-RS
ExceptionMapper for any exception no more specific mapper handles
(ResourceRegistryExceptionMapper, WebApplicationExceptionMapper): a
500 Internal Server Error with the service's JSON error body instead of the container's
HTML page.Defines how an update payload is interpreted against the existing instance state.
Utility class for handling UUID operations specific to Resource Registry persistence.
Utility class for validating caller-supplied UUID strings (path parameters,
query parameters, request body fields) at the point they enter the system.
Emits
X-Warning headers with anti-DoS capping and summary semantics.Shared constants and utilities for
X-Warning header values.Global JAX-RS response filter that automatically extracts accumulated query-parameter
and content warnings from the current JAX-RS
ContainerRequestContext properties
and emits them as X-Warning response headers.Global JAX-RS
ExceptionMapper giving the JSON error body of the service to the
WebApplicationExceptions: the 401 and 403 of the Policy Enforcement
Points, and the errors of the JAX-RS runtime itself (e.g.