r-io suitededuction docsThe default rule-driven deduction strategy of r-io suite. Three Drools rules decide which objectives to keep, which function graph to prefer and which actor to assign; the surrounding Java campaign explores risk configurations, calls the Default planner and publishes unique collaborative processes.
r-io exposes two AbstractProcessGenerator implementations: the native Basic Bloc Satisfaction (native pertinence and expertise ranking, one sequential sub-task per objective) and this Drools generator. Crisis, Healthcare and Production are published profiles of the same Drools pipeline with different scoring rules, not separate algorithms. Simple Satisfaction is the profile the generator requires to exist and to be published.
Objectives_Manager selected in r-ioded, r-iota or r-ioga and its Plans edges.Satisfies, Needs, Implies, Supports, Provides, Consumes relations of the collaborative model.satisfactionProperties: planner, actor selection mode, resource-combination cap, time limit, campaign configuration (preventive and corrective potentialities).DroolsObjectiveFact.DroolsFunctionCandidateFact, here by minimizing the graph KPI duration.DroolsActorCandidateFact, here by minimizing the graph KPI cost.campaignSolution) holding a Solution → Process → Task/Sequence_Flow model with expected dates and assigned resources.The strategy never receives HTTP calls directly. It is instantiated by the deduction service of the governance container, which discovers it through ServiceLoader and runs it inside a campaign.
createDroolsStrategyDialog opens the Simple Satisfaction input component (r-ioded, r-iota, generic app).POST …/r-ioga/solution/deduceSolutionASync builds a GJaxbDeduceASync with the callback port.DeductionImpl.deduceASync: single operation of the governance container.drools:<id>:<version>.addSolution into solutionsCampaigns; progress sent back through deductionASyncCallBackResponse.Because variants are enumerated from DroolsStrategyRegistry.listPublishedDefinitions(), publishing a new rule version in r-ioded immediately adds a selectable strategy without redeploying any Java module. The generator refuses to start if the Simple Satisfaction definition is missing or unpublished (IllegalStateException: The default Drools strategy is not published).
Entry point: doDeduceProcessFromOneObjectivesManager(campaign, mode, collaboration, knowledgeSpace, objectivesManager, data, project, resultsQueue).
The satisfactionProperties array is parsed into the planner type (selectedPlanningSolver, Default by default), the actor selection mode (actorsSelectionMode, PERSON_FIRST), the resource-combination cap, the time limit, the move-improver flag and the campaign configuration that carries the preventive and corrective potentialities chosen by the user.
Every Plans edge of the objectives manager becomes a DroolsObjectiveFact(id, name, priority). The rules run once; if they emit no decision at all, every objective is kept, otherwise only accepted objectives survive (objectivesManager.filterPlans). An empty result stops the campaign with an IllegalStateException. Each decision is traced in the campaign observation.
For each potentiality or actuality of the campaign configuration, the objectives it groups receive one selected function each (inner Cartesian product), then a NONE alternative is added per group and the outer product enumerates the campaign combinations. Preventive and corrective candidates are ordered with the same Drools rules; if scoring fails, the order sent by the front end is kept.
For each retained objective, Satisfies relations give the candidate functions; Needs, Implies and Supports expand each candidate into a recursive function graph. A candidate is discarded when no actor Provides at least one function of its graph.
Each candidate is exposed as a DroolsFunctionCandidateFact with pertinence, priority, the consumed resources and a calculateGraphKPI(name) method. The rules score or reject candidates through the collector; the ranking is a descending sort on the merged score, with natural pertinence as fallback when no rule scored anything.
The strategy injects rankActorCandidates into the planner (planner.setActorCandidateRanker). For every function of a plan, actors that provide it become DroolsActorCandidateFacts with their expertise; the rules score them, expertise is the fallback. ResourceAssigner then resolves fixed and movable resources, either the best assignment or every permitted one.
Chosen functions and assignments become Solution, Process, Task and Sequence_Flow elements; solution.planify() and the Default planner compute expected start and end dates (never below one minute per task) and KPIL indicators. Resource-assignment failures are reported as errors without crashing the campaign.
A campaign-wide fingerprint set (CampaignSolutionHelper.createSignature) drops equivalent function, actor, resource and procedure combinations. Unique solutions are stored through the campaign manager; in FIRST_GOOD_SOLUTION mode the first one is also pushed to the graph and the campaign ends.
definition = registry.published("drools-default-simple-satisfaction-strategy")
objectives = rules(definition, ObjectiveFact(plans.objective, priority)) # keep all if no decision
combinations = cartesian(groupedPotentialityChoices + NONE per group)
if mode == FIRST_GOOD_SOLUTION: combinations = reverse(combinations) # start with the fully specified one
single-thread executor, for combination in combinations:
plansQueue, solutionQueue = new LinkedBlockingQueue()
task1: every second report RUNNING / ENDED / CRASHED with counts and estimate
task2: candidates = findBestOrAllPlansWithFunctions(objectives, combination)
ranked = rules(FunctionCandidateFact(...)) or pertinence
plansQueue <- best plan | every plan (ALL_SOLUTIONS) ; PLAN_POISON_PILL
task3: for plan in plansQueue:
planner = RioDefaultPlanner(actorRanker = rules(ActorCandidateFact(...)))
for assignment in planner.solve(plan): solutionQueue <- createSolution(plan, assignment)
SOLUTION_POISON_PILL
task4: for solution in solutionQueue:
if fingerprints.add(signature(solution)): campaignManager.addSolution(solution); results <- ScenarioResult
if mode == FIRST_GOOD_SOLUTION: publishModelSynchronously(solution); stopThe rules are not .drl files: each profile is a Java text block (STRATEGY_RULES) inside default_strategies/, seeded into the registry at first start. They share one package, three fact imports and a single global, collector. No salience, no agenda group, no insert or modify: rules only talk to the collector.
rule "Accept every objective" when $objective : DroolsObjectiveFact() then collector.accept($objective.getId()); end
rule "Rank functions by duration" when $candidate : DroolsFunctionCandidateFact() then collector.minimizeScoreCandidate($candidate, $candidate.calculateGraphKPI("duration")); end
rule "Rank actors by cost" when $candidate : DroolsActorCandidateFact() then collector.minimizeScoreCandidate($candidate, $candidate.calculateGraphKPI("cost")); end
| Fact | Data exposed to DRL | Collector calls | Fallback |
|---|---|---|---|
| DroolsObjectiveFact | getId(), getName(), getPriority() | accept(id), rejectObjective(id) | No decision at all → every objective retained |
| DroolsFunctionCandidateFact | candidate, objective and function ids/names, getPertinence(), getPriority(), getAllGraphConsumedResources(), calculateGraphKPI(name) | maximizeScoreCandidate, minimizeScoreCandidate, rejectFunctionCandidate | No score → natural pertinence |
| DroolsActorCandidateFact | candidate (= actor id), objective and function ids/names, getExpertise(), calculateGraphKPI(name) | maximizeScoreCandidate, minimizeScoreCandidate, rejectActorCandidate | No score → natural expertise |
minimizeScoreCandidate(c, v) = scoreCandidate(c, -v) maximizeScoreCandidate(c, v) = scoreCandidate(c, v) score[c] = max(score[c], v) # merged with Math::max reject*(c) # removes the score; a later rule may re-score ranked = candidates with a score, sorted descending unknown fact type → IllegalArgumentException
All four definitions are system defaults (systemDefault=true, version 1 PUBLISHED, SHA-256 checksum, one history entry). Only the DRL text and the favorite domain differ; campaign algorithm, facts, planner and persistence are shared.
| Profile | Identifier · domain | Function rule | Actor rule |
|---|---|---|---|
| Simple Satisfaction default | drools-default-simple-satisfaction-strategycollaborative | Rank functions by durationminimize calculateGraphKPI("duration") | Rank actors by costminimize calculateGraphKPI("cost") |
| Crisis Satisfaction | drools-default-crisis-satisfaction-strategycrisis | Rank functions by pertinencemaximize getPertinence() | Rank actors by expertisemaximize getExpertise() |
| Healthcare Satisfaction | drools-default-healthcare-satisfaction-strategyhealth | Multi-criteriamaximize 0.7 × pertinence + 0.3 / (1 + duration / 60) | Multi-criteriamaximize 0.6 × expertise + 0.4 / (1 + cost / 100) |
| Production Satisfaction caveats | drools-default-production-satisfaction-strategyproduction | Pertinence and resource parsimonymaximize 0.5 × pertinence + 0.5 / (1 + consumedResources / 5) | As written in sourcemaximize calculateGraphKPI("cost") |
The Simple Satisfaction text block is the only public one: r-ioded uses it as the template when a new draft is created. The Production profile carries two source-level caveats detailed in the watch points.
A ranking rule may need duration or cost while no process has been generated yet. DroolsFunctionCandidateFact.calculateGraphKPI therefore rebuilds a lightweight temporary process from the recursive function graph, copies the theoretical indicators of each function into simulated task values, and evaluates the requested KPIL indicator on the main task with HLIndicatorManager.
| Model relation | Temporary process translation |
|---|---|
main Needs pre | Task(pre) → Task(main) |
main Implies post | Task(main) → Task(post) |
main Supports support | Task(support) → Task(main) |
| No incoming / outgoing flow | Connected to Start_Event / End_Event |
functions = unique(main + main.allFunctionsRecursively)
for f in functions:
task[f] = Task(f.name); copy f.theoretical indicators → task.simulated
for f in functions:
for pre in f.needs: edge(task[pre], task[f])
for post in f.implies: edge(task[f], task[post])
for s in f.supports: edge(task[s], task[f])
connect Start_Event → tasks without incoming flow
connect tasks without outgoing flow → End_Event
process = Process.buildFromGenericModel(nodes, edges)
return indicatorManager.evaluateIndicatorOnTask("Function:" + name, mainTask)The actor fact reuses the same mechanism: DroolsActorCandidateFact.calculateGraphKPI checks that a Resource:<name> indicator exists, then evaluates Function:<name> on the main task. That mixed lookup is listed in the watch points.
The campaign configuration lists the potentialities (preventive) and actualities (corrective) the user activated, each with the objectives it groups and, per objective, the ordered candidate functions. The inner product keeps the objectives of one group together: an activated group gives exactly one function to each of its objectives. The outer product combines those bundles and adds a NONE alternative per group, so a solution may simply ignore a risk.
FIRST_GOOD_SOLUTION — candidates are ranked and reduced to the best function per objective. Combinations are processed from the last, fully specified one, so an easier NONE combination cannot silently drop a procedure the user selected. The campaign stops after the first unique persisted solution, which is also published to the graph.
ALL_SOLUTIONS — every ranked candidate and every group combination is explored; plans and actor/resource assignments add further Cartesian products (CartesianProduct), and the fingerprint set removes equivalent solutions across the whole campaign. The estimate published to the UI (estimateCampaignSolutionsCount, saturating multiplication) is revised as unique solutions are processed and never decreases.
Risk A: Objective A1 → [Function A, Function B] Objective A2 → [Function C, Function D] inner bundles(A) = [(A,C), (A,D), (B,C), (B,D)] column(A) = [NONE, (A,C), (A,D), (B,C), (B,D)] combinations = product(column(A), column(B), column(actuality C), ...) FIRST_GOOD_SOLUTION : iterate reversed(combinations), stop at first unique solution ALL_SOLUTIONS : iterate all, expand plans × assignments, dedupe by signature
deduce() returns immediately. A single-thread executor (combinationsExecutor) processes combinations one after another, which prevents concurrent writes on the same campaign and graph. Inside one combination, Executors.newFixedThreadPool(4) runs four tasks that communicate through two LinkedBlockingQueues closed by poison pills.
countSolutions in the campaign manager) and emits RUNNING; switches to ENDED only on the last combination or once the first good solution is satisfied, CRASHED on fatal error.PLAN_POISON_PILL.plansQueue — PlanWithFunctions instancesRioDefaultPlanner with the Drools actor ranker, solves each plan, builds Solution/Process models and planifies them; resource shortages become error results, not crashes. Ends with SOLUTION_POISON_PILL.solutionQueue — planned solutionsScenarioResult; publishes the model synchronously in first-good mode. The “move nodes improver” block is present but commented out.Three campaign steps are reported to the UI: “At least one function has been found by objectives”, “At least one actor provides each function”, “All solutions have been deduced”. Cumulative counters (cumulativeSolutionsFound, cumulativeSolutionsProcessed, campaignEstimatedSolutionsCount) survive combination boundaries.
Definitions live in DroolsStrategyRegistry, a singleton persisted as JSON (gind.drools.strategy-store system property, GIND_DROOLS_STRATEGY_STORE environment variable, or <resources>/../DroolsStrategy/drools-strategies.json). Writes go through a temporary file and an atomic move; if persistence fails, defaults stay in memory with a warning.
saveDraft creates a DRAFT version (published version + 1); cloneStrategy suffixes “- copy”; importStrategy validates the imported DRL and suffixes the id with “-import”.
DroolsRuleEngine.validate rejects an empty source, scans the deny-list below, then compiles with KieHelper and ExecutableModelProject; errors are returned as a DroolsRuleValidation.
publish re-validates, freezes the version as PUBLISHED with publishedAt and a SHA-256 checksum, appends it to the history, removes the draft and exposes a new generator variant.
execute(checksum, drl, facts) re-runs the deny-list on every call, compiles once per checksum into a ConcurrentHashMap<String, KieBase>, opens a fresh KieSession, sets the collector global, inserts the facts, fireAllRules() and always disposes the session.
Sources containing any of the tokens below are refused before compilation. Rules remain trusted project assets executed with the rights of the governance service.
Runtime.getRuntimeProcessBuilderSystem.exitjava.io.java.nio.Class.forNamejava.lang.reflectgetClass()| REST endpoint (r-ioded) | Method | Effect |
|---|---|---|
/{app}/r-ioded/drools/strategies | GET · POST | List definitions · save a draft |
…/strategies/{id} | GET | Read one definition with versions and history |
…/strategies/{id}/clone | POST | Duplicate a definition |
…/strategies/{id}/export · …/strategies/import | GET · POST | Zip archive <id>-maven-test.zip: pom.xml, README.md, src/test/resources/drools-strategy.json, ExportedDroolsStrategyTest.java (import: max 100 entries, 5 MB JSON, exactly one descriptor) |
…/strategies/{id}/validate · …/publish | POST | Validate the draft · publish it |
…/strategies/{id}/test | POST | Run DRAFT or PUBLISHED rules on user-provided objective, function and actor facts; returns accepted/rejected objectives, candidate scores and executionTimeMs |
| satisfactionProperties key | Default | Used for |
|---|---|---|
selectedPlanningSolver | Default | Planner type; Choco and Opta are refused |
actorsSelectionMode | PERSON_FIRST | How actors are preferred during assignment |
numberOfResourceCombinations | — | Cap on enumerated resource assignments |
numberOfSolutions | — | Requested number of solutions in ALL_SOLUTIONS |
terminationSpentLimit | — | Time limit of the campaign |
campaignConfiguration | — | Activated potentialities/actualities and candidate functions |
activeMoveImprover | false | Read and passed to the planner; the improver call itself is commented out |
objectivesManager · embeddedObjectivesManagerModel | — | Root of the deduction |
Deduction dialog. createDroolsStrategyDialog (exposed through getJavascriptFunction() with showInputs, showReport, deploy, droolsStrategyId, droolsStrategyVersion) delegates to DroolsSimpleSatisfactionstrategyComponent, whose deduce() serializes exactly the keys on the left.
r-ioded workspace. DeductionPanelComponent offers four views — CATALOG (native and Drools strategies), EDITOR (three rule sections: objective selection, function ranking, actor ranking), TESTS (facts loaded from the current model, scores returned by the test endpoint) and HISTORY — backed by DroolsStrategiesService (list, saveDraft, clone, export, import, validate, publish, test).
The Java description announces “actors by expertise”; the executable rule minimizes the graph KPI cost. This page follows the rule.
DroolsActorCandidateFact.calculateGraphKPI checks for Resource:<name> but evaluates Function:<name>; the default actor rule (cost) depends on this mixed path.
The Production actor rule calls maximizeScoreCandidate(cost): as written, the most expensive actor ranks first, contrary to the “actors by cost” intent.
getAllGraphConsumedResources() returns an empty list until the temporary process has been rebuilt by a previous calculateGraphKPI call, so the resource term may stay constant.
createPlannerResolver throws UnsupportedOperationException for any solver other than Default; Choco and OptaPlanner modules are also excluded from the governance build.
The ProcessImproversManager.improveOnlyWithSelectImprovers("move nodes improver") block of task 4 is commented out although the flag is still read.
Module java/backend/gind-governance/gind-governance-workflow-deduction-strategy-drools, package fr.emac.gind.workflow.deduction.drools.
DroolsProcessGenerator.javaSPI entry, variants per published definition, identifier, default-profile requirement.DroolsStrategyDeductionCampaign.javaParameters, objective filtering, combinations, four-task pipeline, actor ranker, estimates, publication.DroolsStrategyRegistry.javaDefaults, drafts, clone, import/export, validate, publish, history, JSON store.runtime/DroolsRuleEngine.javaDeny-list, KieHelper compilation, checksum cache, session execution.runtime/DroolsDecisionCollector.javaObjective decisions, normalized scores, rejections.runtime/Drools{Objective,FunctionCandidate,ActorCandidate}Fact.javaDRL-facing data and temporary graph KPI evaluation.default_strategies/Drools*SatisfactionStrategy.javaSimple, Crisis, Healthcare and Production text-block rules.DroolsStrategyProjectArchive.javaMaven test archive format for export and import.gind-webapp-r-ioded/…/DroolsStrategiesResource.javaREST façade used by the r-ioded workspace.gind-governance-workflow-planner-default/…/ResourceAssigner.javaConsumes the injected actor ranker during assignment.La stratégie de déduction par défaut de r-io suite, pilotée par règles. Trois règles Drools décident des objectifs à garder, du graphe de fonctions à préférer et de l’acteur à affecter ; la campagne Java qui les entoure explore les configurations de risques, appelle le planificateur Default et publie des processus collaboratifs uniques.
r-io expose deux implémentations d’AbstractProcessGenerator : la stratégie native Basic Bloc Satisfaction (classement natif par pertinence et expertise, une sous-tâche séquentielle par objectif) et ce générateur Drools. Crisis, Healthcare et Production sont des profils publiés du même pipeline Drools avec d’autres règles de score, pas des algorithmes distincts. Simple Satisfaction est le profil dont le générateur exige l’existence et la publication.
Objectives_Manager sélectionné dans r-ioded, r-iota ou r-ioga et ses arêtes Plans.Satisfies, Needs, Implies, Supports, Provides, Consumes du modèle collaboratif.satisfactionProperties : planificateur, mode de sélection des acteurs, plafond de combinaisons de ressources, limite de temps, configuration de campagne (potentialités préventives et correctives).DroolsObjectiveFact.DroolsFunctionCandidateFact, ici en minimisant le KPI de graphe duration.DroolsActorCandidateFact, ici en minimisant le KPI de graphe cost.campaignSolution) portant un modèle Solution → Process → Task/Sequence_Flow avec dates attendues et ressources affectées.La stratégie ne reçoit jamais d’appel HTTP directement. Elle est instanciée par le service de déduction du conteneur de gouvernance, qui la découvre via ServiceLoader et l’exécute dans une campagne.
createDroolsStrategyDialog ouvre le composant de saisie Simple Satisfaction (r-ioded, r-iota, application générique).POST …/r-ioga/solution/deduceSolutionASync construit un GJaxbDeduceASync avec le port de rappel.DeductionImpl.deduceASync : unique opération du conteneur de gouvernance.drools:<id>:<version>.addSolution dans solutionsCampaigns ; progression renvoyée par deductionASyncCallBackResponse.Les variantes étant énumérées depuis DroolsStrategyRegistry.listPublishedDefinitions(), publier une nouvelle version de règles dans r-ioded ajoute immédiatement une stratégie sélectionnable sans redéployer de module Java. Le générateur refuse de démarrer si la définition Simple Satisfaction est absente ou non publiée (IllegalStateException: The default Drools strategy is not published).
Point d’entrée : doDeduceProcessFromOneObjectivesManager(campaign, mode, collaboration, knowledgeSpace, objectivesManager, data, project, resultsQueue).
Le tableau satisfactionProperties est analysé pour obtenir le type de planificateur (selectedPlanningSolver, Default par défaut), le mode de sélection des acteurs (actorsSelectionMode, PERSON_FIRST), le plafond de combinaisons de ressources, la limite de temps, l’indicateur d’amélioration par déplacement et la configuration de campagne qui porte les potentialités préventives et correctives choisies par l’utilisateur.
Chaque arête Plans du gestionnaire d’objectifs devient un DroolsObjectiveFact(id, name, priority). Les règles s’exécutent une fois ; si elles n’émettent aucune décision, tous les objectifs sont conservés, sinon seuls les objectifs acceptés survivent (objectivesManager.filterPlans). Un résultat vide arrête la campagne par une IllegalStateException. Chaque décision est tracée dans l’observation de la campagne.
Pour chaque potentialité ou actualité de la configuration de campagne, les objectifs qu’elle regroupe reçoivent chacun une fonction sélectionnée (produit cartésien interne), puis une alternative NONE est ajoutée par groupe et le produit externe énumère les combinaisons de la campagne. Les candidats préventifs et correctifs sont ordonnés avec les mêmes règles Drools ; en cas d’échec du score, l’ordre envoyé par le front est conservé.
Pour chaque objectif retenu, les relations Satisfies donnent les fonctions candidates ; Needs, Implies et Supports développent chaque candidat en graphe récursif de fonctions. Un candidat est écarté quand aucun acteur ne Provides au moins une fonction de son graphe.
Chaque candidat est exposé comme DroolsFunctionCandidateFact avec pertinence, priorité, ressources consommées et une méthode calculateGraphKPI(name). Les règles notent ou rejettent les candidats via le collecteur ; le classement est un tri décroissant sur le score fusionné, avec la pertinence naturelle en repli quand aucune règle n’a noté.
La stratégie injecte rankActorCandidates dans le planificateur (planner.setActorCandidateRanker). Pour chaque fonction d’un plan, les acteurs qui la fournissent deviennent des DroolsActorCandidateFact avec leur expertise ; les règles les notent, l’expertise est le repli. ResourceAssigner résout ensuite ressources fixes et mobiles, soit la meilleure affectation, soit toutes celles permises.
Fonctions choisies et affectations deviennent des éléments Solution, Process, Task et Sequence_Flow ; solution.planify() et le planificateur Default calculent dates de début et de fin attendues (jamais moins d’une minute par tâche) et indicateurs KPIL. Les échecs d’affectation de ressources sont rapportés comme erreurs sans faire crasher la campagne.
Un ensemble d’empreintes à l’échelle de la campagne (CampaignSolutionHelper.createSignature) écarte les combinaisons équivalentes de fonctions, acteurs, ressources et procédures. Les solutions uniques sont stockées via le gestionnaire de campagnes ; en mode FIRST_GOOD_SOLUTION, la première est aussi poussée dans le graphe et la campagne s’arrête.
definition = registre.publiee("drools-default-simple-satisfaction-strategy")
objectifs = regles(definition, ObjectiveFact(plans.objectif, priorite)) # tout garder si aucune décision
combinaisons = cartesien(choixDePotentialitesGroupes + NONE par groupe)
si mode == FIRST_GOOD_SOLUTION : combinaisons = inverser(combinaisons) # partir de la plus spécifiée
exécuteur mono-thread, pour combinaison dans combinaisons :
plansQueue, solutionQueue = new LinkedBlockingQueue()
tâche1 : chaque seconde, rapporter RUNNING / ENDED / CRASHED avec compteurs et estimation
tâche2 : candidats = findBestOrAllPlansWithFunctions(objectifs, combinaison)
classes = regles(FunctionCandidateFact(...)) ou pertinence
plansQueue <- meilleur plan | tous les plans (ALL_SOLUTIONS) ; PLAN_POISON_PILL
tâche3 : pour plan dans plansQueue :
planificateur = RioDefaultPlanner(classeurActeurs = regles(ActorCandidateFact(...)))
pour affectation dans planificateur.solve(plan) : solutionQueue <- createSolution(plan, affectation)
SOLUTION_POISON_PILL
tâche4 : pour solution dans solutionQueue :
si empreintes.add(signature(solution)) : gestionnaireCampagnes.addSolution(solution) ; résultats <- ScenarioResult
si mode == FIRST_GOOD_SOLUTION : publierModeleEnSynchrone(solution) ; stopLes règles ne sont pas des fichiers .drl : chaque profil est un bloc de texte Java (STRATEGY_RULES) dans default_strategies/, injecté dans le registre au premier démarrage. Elles partagent un package, trois imports de faits et un seul global, collector. Pas de salience, pas d’agenda group, pas d’insert ni de modify : les règles ne parlent qu’au collecteur.
rule "Accept every objective" when $objective : DroolsObjectiveFact() then collector.accept($objective.getId()); end
rule "Rank functions by duration" when $candidate : DroolsFunctionCandidateFact() then collector.minimizeScoreCandidate($candidate, $candidate.calculateGraphKPI("duration")); end
rule "Rank actors by cost" when $candidate : DroolsActorCandidateFact() then collector.minimizeScoreCandidate($candidate, $candidate.calculateGraphKPI("cost")); end
| Fait | Données exposées au DRL | Appels au collecteur | Repli |
|---|---|---|---|
| DroolsObjectiveFact | getId(), getName(), getPriority() | accept(id), rejectObjective(id) | Aucune décision → tous les objectifs conservés |
| DroolsFunctionCandidateFact | ids/noms du candidat, de l’objectif et de la fonction, getPertinence(), getPriority(), getAllGraphConsumedResources(), calculateGraphKPI(name) | maximizeScoreCandidate, minimizeScoreCandidate, rejectFunctionCandidate | Aucun score → pertinence naturelle |
| DroolsActorCandidateFact | candidat (= id de l’acteur), ids/noms de l’objectif et de la fonction, getExpertise(), calculateGraphKPI(name) | maximizeScoreCandidate, minimizeScoreCandidate, rejectActorCandidate | Aucun score → expertise naturelle |
minimizeScoreCandidate(c, v) = scoreCandidate(c, -v) maximizeScoreCandidate(c, v) = scoreCandidate(c, v) score[c] = max(score[c], v) # fusion par Math::max reject*(c) # retire le score ; une règle ultérieure peut re-noter classes = candidats notés, triés par score décroissant type de fait inconnu → IllegalArgumentException
Les quatre définitions sont des valeurs système par défaut (systemDefault=true, version 1 PUBLISHED, somme SHA-256, une entrée d’historique). Seuls le texte DRL et le domaine privilégié diffèrent ; algorithme de campagne, faits, planificateur et persistance sont partagés.
| Profil | Identifiant · domaine | Règle fonctions | Règle acteurs |
|---|---|---|---|
| Simple Satisfaction défaut | drools-default-simple-satisfaction-strategycollaborative | Rank functions by durationminimize calculateGraphKPI("duration") | Rank actors by costminimize calculateGraphKPI("cost") |
| Crisis Satisfaction | drools-default-crisis-satisfaction-strategycrisis | Rank functions by pertinencemaximize getPertinence() | Rank actors by expertisemaximize getExpertise() |
| Healthcare Satisfaction | drools-default-healthcare-satisfaction-strategyhealth | Multicritèremaximize 0,7 × pertinence + 0,3 / (1 + duration / 60) | Multicritèremaximize 0,6 × expertise + 0,4 / (1 + cost / 100) |
| Production Satisfaction réserves | drools-default-production-satisfaction-strategyproduction | Pertinence et parcimonie des ressourcesmaximize 0,5 × pertinence + 0,5 / (1 + ressourcesConsommées / 5) | Tel qu’écrit dans le codemaximize calculateGraphKPI("cost") |
Le bloc de texte Simple Satisfaction est le seul public : r-ioded l’utilise comme gabarit à la création d’un brouillon. Le profil Production porte deux réserves au niveau du code, détaillées dans les points de vigilance.
Une règle de classement peut avoir besoin de duration ou cost alors qu’aucun processus n’a encore été généré. DroolsFunctionCandidateFact.calculateGraphKPI reconstruit donc un processus temporaire léger depuis le graphe récursif de fonctions, copie les indicateurs théoriques de chaque fonction dans les valeurs simulées des tâches et évalue l’indicateur KPIL demandé sur la tâche principale avec HLIndicatorManager.
| Relation du modèle | Traduction en processus temporaire |
|---|---|
main Needs pre | Task(pre) → Task(main) |
main Implies post | Task(main) → Task(post) |
main Supports support | Task(support) → Task(main) |
| Aucun flux entrant / sortant | Relié à Start_Event / End_Event |
fonctions = unique(principale + principale.toutesFonctionsRecursivement)
pour f dans fonctions :
tache[f] = Task(f.nom) ; copier indicateurs théoriques de f → tache.simules
pour f dans fonctions :
pour pre dans f.needs : arete(tache[pre], tache[f])
pour post dans f.implies : arete(tache[f], tache[post])
pour s dans f.supports : arete(tache[s], tache[f])
relier Start_Event → tâches sans flux entrant
relier tâches sans flux sortant → End_Event
processus = Process.buildFromGenericModel(noeuds, aretes)
retourner indicatorManager.evaluateIndicatorOnTask("Function:" + nom, tachePrincipale)Le fait acteur réutilise le même mécanisme : DroolsActorCandidateFact.calculateGraphKPI vérifie qu’un indicateur Resource:<nom> existe, puis évalue Function:<nom> sur la tâche principale. Cette recherche mixte figure dans les points de vigilance.
La configuration de campagne liste les potentialités (préventives) et actualités (correctives) activées par l’utilisateur, chacune avec les objectifs qu’elle regroupe et, par objectif, les fonctions candidates ordonnées. Le produit interne garde ensemble les objectifs d’un groupe : un groupe activé donne exactement une fonction à chacun de ses objectifs. Le produit externe combine ces lots et ajoute une alternative NONE par groupe, si bien qu’une solution peut simplement ignorer un risque.
FIRST_GOOD_SOLUTION — les candidats sont classés et réduits à la meilleure fonction par objectif. Les combinaisons sont traitées à partir de la dernière, la plus spécifiée, pour qu’une combinaison NONE plus facile n’omette pas silencieusement une procédure choisie par l’utilisateur. La campagne s’arrête après la première solution unique persistée, également publiée dans le graphe.
ALL_SOLUTIONS — tous les candidats classés et toutes les combinaisons de groupes sont explorés ; plans et affectations acteurs/ressources ajoutent d’autres produits cartésiens (CartesianProduct), et l’ensemble d’empreintes retire les solutions équivalentes sur toute la campagne. L’estimation publiée à l’interface (estimateCampaignSolutionsCount, multiplication saturante) est révisée au fil des solutions uniques traitées et ne diminue jamais.
Risque A : Objectif A1 → [Fonction A, Fonction B] Objectif A2 → [Fonction C, Fonction D] lots internes(A) = [(A,C), (A,D), (B,C), (B,D)] colonne(A) = [NONE, (A,C), (A,D), (B,C), (B,D)] combinaisons = produit(colonne(A), colonne(B), colonne(actualité C), ...) FIRST_GOOD_SOLUTION : parcourir inverse(combinaisons), stop à la première solution unique ALL_SOLUTIONS : tout parcourir, développer plans × affectations, dédoublonner par signature
deduce() rend la main immédiatement. Un exécuteur mono-thread (combinationsExecutor) traite les combinaisons l’une après l’autre, ce qui évite les écritures concurrentes sur la même campagne et le même graphe. Dans une combinaison, Executors.newFixedThreadPool(4) exécute quatre tâches qui communiquent par deux LinkedBlockingQueue fermées par des pilules empoisonnées.
countSolutions dans le gestionnaire de campagnes) et émet RUNNING ; passe à ENDED seulement sur la dernière combinaison ou dès que la première bonne solution est satisfaite, CRASHED sur erreur fatale.PLAN_POISON_PILL.plansQueue — instances de PlanWithFunctionsRioDefaultPlanner avec le classeur d’acteurs Drools, résout chaque plan, construit les modèles Solution/Process et les planifie ; les pénuries de ressources deviennent des résultats d’erreur, pas des crashs. Se termine par SOLUTION_POISON_PILL.solutionQueue — solutions planifiéesScenarioResult ; publie le modèle en synchrone en mode première bonne solution. Le bloc « move nodes improver » est présent mais commenté.Trois étapes de campagne sont rapportées à l’interface : « At least one function has been found by objectives », « At least one actor provides each function », « All solutions have been deduced ». Les compteurs cumulés (cumulativeSolutionsFound, cumulativeSolutionsProcessed, campaignEstimatedSolutionsCount) survivent aux frontières de combinaison.
Les définitions vivent dans DroolsStrategyRegistry, un singleton persisté en JSON (propriété système gind.drools.strategy-store, variable d’environnement GIND_DROOLS_STRATEGY_STORE, sinon <ressources>/../DroolsStrategy/drools-strategies.json). Les écritures passent par un fichier temporaire et un déplacement atomique ; si la persistance échoue, les valeurs par défaut restent en mémoire avec un avertissement.
saveDraft crée une version DRAFT (version publiée + 1) ; cloneStrategy suffixe « - copy » ; importStrategy valide le DRL importé et suffixe l’identifiant par « -import ».
DroolsRuleEngine.validate rejette une source vide, parcourt la liste d’interdiction ci-dessous, puis compile avec KieHelper et ExecutableModelProject ; les erreurs reviennent dans une DroolsRuleValidation.
publish revalide, fige la version en PUBLISHED avec publishedAt et une somme SHA-256, l’ajoute à l’historique, supprime le brouillon et expose une nouvelle variante du générateur.
execute(checksum, drl, facts) rejoue la liste d’interdiction à chaque appel, compile une seule fois par somme de contrôle dans une ConcurrentHashMap<String, KieBase>, ouvre une KieSession neuve, positionne le global collector, insère les faits, fireAllRules() et libère toujours la session.
Les sources contenant l’un des jetons ci-dessous sont refusées avant compilation. Les règles restent des ressources de projet de confiance, exécutées avec les droits du service de gouvernance.
Runtime.getRuntimeProcessBuilderSystem.exitjava.io.java.nio.Class.forNamejava.lang.reflectgetClass()| Endpoint REST (r-ioded) | Méthode | Effet |
|---|---|---|
/{app}/r-ioded/drools/strategies | GET · POST | Lister les définitions · enregistrer un brouillon |
…/strategies/{id} | GET | Lire une définition avec versions et historique |
…/strategies/{id}/clone | POST | Dupliquer une définition |
…/strategies/{id}/export · …/strategies/import | GET · POST | Archive zip <id>-maven-test.zip : pom.xml, README.md, src/test/resources/drools-strategy.json, ExportedDroolsStrategyTest.java (import : 100 entrées max, 5 Mo de JSON, exactement un descripteur) |
…/strategies/{id}/validate · …/publish | POST | Valider le brouillon · le publier |
…/strategies/{id}/test | POST | Exécuter les règles DRAFT ou PUBLISHED sur des faits objectifs, fonctions et acteurs fournis ; renvoie objectifs acceptés/rejetés, scores des candidats et executionTimeMs |
| Clé de satisfactionProperties | Défaut | Usage |
|---|---|---|
selectedPlanningSolver | Default | Type de planificateur ; Choco et Opta sont refusés |
actorsSelectionMode | PERSON_FIRST | Préférence d’acteurs pendant l’affectation |
numberOfResourceCombinations | — | Plafond d’affectations de ressources énumérées |
numberOfSolutions | — | Nombre de solutions demandé en ALL_SOLUTIONS |
terminationSpentLimit | — | Limite de temps de la campagne |
campaignConfiguration | — | Potentialités/actualités activées et fonctions candidates |
activeMoveImprover | false | Lu et transmis au planificateur ; l’appel à l’improver est lui-même commenté |
objectivesManager · embeddedObjectivesManagerModel | — | Racine de la déduction |
Dialogue de déduction. createDroolsStrategyDialog (exposée par getJavascriptFunction() avec showInputs, showReport, deploy, droolsStrategyId, droolsStrategyVersion) délègue à DroolsSimpleSatisfactionstrategyComponent, dont deduce() sérialise exactement les clés de gauche.
Espace de travail r-ioded. DeductionPanelComponent propose quatre vues — CATALOG (stratégies natives et Drools), EDITOR (trois sections de règles : sélection des objectifs, classement des fonctions, classement des acteurs), TESTS (faits chargés depuis le modèle courant, scores renvoyés par l’endpoint de test) et HISTORY — appuyées sur DroolsStrategiesService (list, saveDraft, clone, export, import, validate, publish, test).
La description Java annonce « acteurs par expertise » ; la règle exécutable minimise le KPI de graphe cost. Cette page suit la règle.
DroolsActorCandidateFact.calculateGraphKPI vérifie Resource:<nom> mais évalue Function:<nom> ; la règle acteurs par défaut (cost) dépend de ce chemin mixte.
La règle acteurs Production appelle maximizeScoreCandidate(cost) : telle quelle, l’acteur le plus coûteux passe en tête, à l’inverse de l’intention « acteurs par coût ».
getAllGraphConsumedResources() renvoie une liste vide tant que le processus temporaire n’a pas été reconstruit par un appel préalable à calculateGraphKPI ; le terme ressources peut donc rester constant.
createPlannerResolver lève UnsupportedOperationException pour tout solveur autre que Default ; les modules Choco et OptaPlanner sont aussi exclus du build de la gouvernance.
Le bloc ProcessImproversManager.improveOnlyWithSelectImprovers("move nodes improver") de la tâche 4 est commenté bien que l’indicateur soit toujours lu.
Module java/backend/gind-governance/gind-governance-workflow-deduction-strategy-drools, package fr.emac.gind.workflow.deduction.drools.
DroolsProcessGenerator.javaEntrée SPI, variantes par définition publiée, identifiant, exigence du profil par défaut.DroolsStrategyDeductionCampaign.javaParamètres, filtrage des objectifs, combinaisons, pipeline à quatre tâches, classeur d’acteurs, estimations, publication.DroolsStrategyRegistry.javaValeurs par défaut, brouillons, clonage, import/export, validation, publication, historique, stockage JSON.runtime/DroolsRuleEngine.javaListe d’interdiction, compilation KieHelper, cache par somme de contrôle, exécution de session.runtime/DroolsDecisionCollector.javaDécisions d’objectifs, scores normalisés, rejets.runtime/Drools{Objective,FunctionCandidate,ActorCandidate}Fact.javaDonnées exposées au DRL et évaluation du KPI de graphe temporaire.default_strategies/Drools*SatisfactionStrategy.javaRègles en blocs de texte Simple, Crisis, Healthcare et Production.DroolsStrategyProjectArchive.javaFormat d’archive de test Maven pour l’export et l’import.gind-webapp-r-ioded/…/DroolsStrategiesResource.javaFaçade REST utilisée par l’espace de travail r-ioded.gind-governance-workflow-planner-default/…/ResourceAssigner.javaConsomme le classeur d’acteurs injecté pendant l’affectation.