fr.gouv.vitam.metadata.core.graph.api

Interface GraphComputeService

All Superinterfaces:

AutoCloseable, VitamAutoCloseable, VitamCache<String,org.bson.Document>

All Known Implementing Classes:

GraphComputeServiceImpl

public interface GraphComputeService
extends VitamCache<String,org.bson.Document>, VitamAutoCloseable

This class get units where calculated data are modified Zip generated files and store the zipped file in the offer.

Field Summary

Fields

Modifier and Type	Field and Description
static String	$_SET
static Integer	concurrencyLevel
static ExecutorService	executor
static int	START_DEPTH

Method Summary

Modifier and Type	Method and Description
void	bulkElasticsearch(MetadataCollections metaDaCollection, List<org.bson.Document> collection) Bulk save in elasticsearch
void	bulkElasticsearch(MetadataCollections metaDaCollection, Set<String> collection) Bulk save in elasticsearch
void	bulkUpdateMongo(MetadataCollections metaDaCollection, List<com.mongodb.client.model.WriteModel<org.bson.Document>> collection) Bulk write in mongodb
GraphComputeResponse	computeGraph(com.fasterxml.jackson.databind.JsonNode queryDSL) If workflow of compute graph in progress, do not execute this method Should be exposed in the API
default void	computeGraph(MetadataCollections metadataCollections, List<org.bson.Document> documents) Generic method to calculate graph for unit and object group
GraphComputeResponse	computeGraph(MetadataCollections metadataCollections, Set<String> unitsId, boolean computeObjectGroupGraph) Compute graph for unit/got from all parents
default com.mongodb.client.model.UpdateOneModel<org.bson.Document>	computeObjectGroupGraph(org.bson.Document document) Create update model for ObjectGroup
default void	computeObjectGroupGraph(Set<String> originatingAgencies, Set<String> unitParents, List<String> up) For ObjectGroup, we only get graph data (sps) from only unit represents (up) We do not loop over all parent of parent until root units As not concurrence expected, no problem of inconsistency, Else, if parallel compute is needed, then, we have to loop over all units (until root units) or to implements optimistic lock on _glpd
default com.mongodb.client.model.UpdateOneModel<org.bson.Document>	computeUnitGraph(org.bson.Document document) Create update model for Unit
default void	computeUnitGraphUsingDirectParents(List<GraphRelation> graphRels, String unitId, List<String> up, int currentDepth) Recursive method that compute graph using only _up With global (by reference variable graphRels, we get all needed informations from all parent of the given unit unitId.
boolean	isInProgress()
default void	preLoadCache(List<org.bson.Document> documents) Get data from database and pre-populate unitCache

Methods inherited from interface fr.gouv.vitam.common.cache.VitamCache

getCache

Methods inherited from interface fr.gouv.vitam.common.model.VitamAutoCloseable

close

Field Detail

$_SET

static final String $_SET

See Also:

Constant Field Values

START_DEPTH

static final int START_DEPTH

See Also:

Constant Field Values

concurrencyLevel

static final Integer concurrencyLevel

executor

static final ExecutorService executor

Method Detail

computeGraph

GraphComputeResponse computeGraph(com.fasterxml.jackson.databind.JsonNode queryDSL)
                           throws MetaDataException

If workflow of compute graph in progress, do not execute this method Should be exposed in the API

Returns:

the map of collection:number of treated documents

Throws:

MetaDataException

computeGraph

GraphComputeResponse computeGraph(MetadataCollections metadataCollections,
                                  Set<String> unitsId,
                                  boolean computeObjectGroupGraph)

Compute graph for unit/got from all parents

Parameters:

metadataCollections - the collection concerned by the build of the graph

unitsId - the collection of units subject of computing graph

computeObjectGroupGraph - true mean compute graph

Returns:

The collection of object group treated or to be treated bu an other process. This collection contains got's id of concerning units. Empty collection is returned if computeGraph of object group.

preLoadCache

default void preLoadCache(List<org.bson.Document> documents)
                   throws MetaDataException

Get data from database and pre-populate unitCache

Parameters:

documents -

Throws:

MetaDataException

computeGraph

default void computeGraph(MetadataCollections metadataCollections,
                          List<org.bson.Document> documents)
                   throws MetaDataException

Generic method to calculate graph for unit and object group

Parameters:

metadataCollections - the type the collection (Unit or ObjectGroup)

documents - the concerning collection of documents

Throws:

MetaDataException

computeUnitGraph

default com.mongodb.client.model.UpdateOneModel<org.bson.Document> computeUnitGraph(org.bson.Document document)
                                                                             throws VitamRuntimeException

Create update model for Unit

Parameters:

document -

Returns:

UpdateOneModel for Unit

Throws:

MetaDataException

VitamRuntimeException

computeObjectGroupGraph

default com.mongodb.client.model.UpdateOneModel<org.bson.Document> computeObjectGroupGraph(org.bson.Document document)
                                                                                    throws VitamRuntimeException

Create update model for ObjectGroup

Parameters:

document -

Returns:

UpdateOneModel for ObjectGroup

Throws:

MetaDataException

VitamRuntimeException

computeUnitGraphUsingDirectParents

default void computeUnitGraphUsingDirectParents(List<GraphRelation> graphRels,
                                                String unitId,
                                                List<String> up,
                                                int currentDepth)
                                         throws VitamRuntimeException

Recursive method that compute graph using only _up With global (by reference variable graphRels, we get all needed informations from all parent of the given unit unitId.

Parameters:

graphRels -

unitId -

up -

currentDepth - the current depth, initially equals to 1

Throws:

ExecutionException

VitamRuntimeException

computeObjectGroupGraph

default void computeObjectGroupGraph(Set<String> originatingAgencies,
                                     Set<String> unitParents,
                                     List<String> up)
                              throws VitamRuntimeException

For ObjectGroup, we only get graph data (sps) from only unit represents (up) We do not loop over all parent of parent until root units As not concurrence expected, no problem of inconsistency, Else, if parallel compute is needed, then, we have to loop over all units (until root units) or to implements optimistic lock on _glpd

Parameters:

originatingAgencies -

unitParents -

up -

Throws:

VitamRuntimeException

bulkUpdateMongo

void bulkUpdateMongo(MetadataCollections metaDaCollection,
                     List<com.mongodb.client.model.WriteModel<org.bson.Document>> collection)
              throws DatabaseException

Bulk write in mongodb

Parameters:

metaDaCollection -

collection -

Throws:

DatabaseException

bulkElasticsearch

void bulkElasticsearch(MetadataCollections metaDaCollection,
                       Set<String> collection)
                throws DatabaseException

Bulk save in elasticsearch

Parameters:

metaDaCollection -

collection - of id of documents

Throws:

DatabaseException

bulkElasticsearch

void bulkElasticsearch(MetadataCollections metaDaCollection,
                       List<org.bson.Document> collection)
                throws DatabaseException

Bulk save in elasticsearch

Parameters:

metaDaCollection -

collection - of documents

Throws:

DatabaseException

isInProgress

boolean isInProgress()