Package org.finos.tracdap.api

Class TracMetadataApiGrpc.TracMetadataApiImplBase

java.lang.Object
org.finos.tracdap.api.TracMetadataApiGrpc.TracMetadataApiImplBase
All Implemented Interfaces:
io.grpc.BindableService, TracMetadataApiGrpc.AsyncService
Enclosing class:
TracMetadataApiGrpc
public abstract static class TracMetadataApiGrpc.TracMetadataApiImplBase extends Object implements io.grpc.BindableService, TracMetadataApiGrpc.AsyncService
Base class for the server implementation of the service TracMetadataApi. 

 Public API for creating, updating, reading and searching for objects in the TRAC metadata store.
 The TRAC metadata API is expressed in terms of Objects and Tags. Objects are
 structural items (nouns and verbs) such as data, models and jobs that describe
 resources and operations on the TRAC platform. Tags contain descriptive and
 informational data and provide a means to classify, catalogue and control objects.
 Tags can also be used to describe the structure of applications built on the TRAC
 platform. For more information on the TRAC metadata model, refer to the
 documentation for ObjectDefinition and Tag.
 The write API allows objects to be created directly, by supplying an object
 definition and a set of tags. These definitions and tags are validated,
 assigned an ID and version (in a tag header) then saved as they are. Only
 certain types of objects can be created / updated directly via the public API
 (currently FLOW and CUSTOM objects). Other types of objects are created by TRAC
 as a result of operations on the platform, for example a model import job will
 create a model definition.
 Creating a new version of an object is very similar to creating a new object,
 in that the entire metadata definition must be supplied. TRAC will perform
 validation to make sure the new definition is a valid version update from the
 previous version - the semantics of versioning depend on the particular object
 type.
 The metadata write API also provides a means for updating tags (i.e. creating
 a new tag version); tag updates are allowed for all object types via the public
 API. The current API requires a whole new tag to be supplied, this will be
 replaced in a future version with an API that supplies attributes changes as a
 set of add/modify/remove operations.
 The read API is for reading metadata from the metadata store when the IDs of the
 metadata items are known. The easiest way to read metadata is using TagSelectors,
 which may be present in other metadata items (e.g. job definitions record tag
 selectors to indicate which versions of resources were used in a job) or can be
 easily constructed from an object ID or tag header. HTTP GET calls are also
 available for REST clients (REST clients can still use selectors with POST
 requests).
 Metadata searches are performed using tag attributes, as well as an object type
 and a few top-level parameters to handle versioning and temporality. See the
 SearchParameters object for a more detailed description. The result of a search
 call is a list of matching tags, which are always arranged with the most recent
 tags first. A search that matches no results will return an empty list.
 This API is a multi-tenant API. For gRPC requests every request includes a
 tenant code, for REST requests the tenant code is the first element of every
 path.
 @see tracdap.metadata.ObjectDefinition
 @see tracdap.metadata.Tag
 @see tracdap.metadata.TagHeader
 @see tracdap.metadata.TagSelector
 @see tracdap.metadata.TagUpdate
 @see tracdap.metadata.SearchParameters

  • Constructor Details

    • TracMetadataApiImplBase

      public TracMetadataApiImplBase()

  • Method Details

    • bindService

      public final io.grpc.ServerServiceDefinition bindService()
      Specified by:
      bindService in interface io.grpc.BindableService