Upgrade EDC version to 0.10.1

oeg-upm · Jan 15, 2025 · 88dfee8 · 88dfee8
1 parent 26aa5fc
commit 88dfee8
Show file tree

Hide file tree

Showing 11 changed files with 75 additions and 29 deletions.
diff --git a/...src/main/java/org/upm/inesdata/edc/extension/policy/services/AlwaysTruePolicyService.java b/...src/main/java/org/upm/inesdata/edc/extension/policy/services/AlwaysTruePolicyService.java
@@ -14,6 +14,7 @@
 
 package org.upm.inesdata.edc.extension.policy.services;
 
+import org.eclipse.edc.policy.engine.spi.PolicyContext;
 import org.upm.inesdata.edc.extension.policy.AlwaysTruePolicyConstants;
 import org.eclipse.edc.policy.engine.spi.PolicyEngine;
 import org.eclipse.edc.policy.engine.spi.RuleBindingRegistry;
@@ -41,7 +42,7 @@ public void registerPolicy() {
         ruleBindingRegistry.bind("USE", ALL_SCOPES);
         ruleBindingRegistry.bind(AlwaysTruePolicyConstants.EXPRESSION_LEFT_VALUE, ALL_SCOPES);
         policyEngine.registerFunction(
-                ALL_SCOPES,
+                PolicyContext.class,
                 Permission.class,
                 AlwaysTruePolicyConstants.EXPRESSION_LEFT_VALUE,
                 (operator, rightValue, rule, context1) -> operator.equals(Operator.EQ) &&

diff --git a/extensions/policy-referring-connector/build.gradle.kts b/extensions/policy-referring-connector/build.gradle.kts
@@ -7,5 +7,7 @@ dependencies {
     api(libs.edc.auth.spi)
     api(libs.edc.policy.engine.spi)
     api(libs.edc.contract.spi)
+    api(libs.edc.catalog.spi)
+    api(libs.edc.participant.spi)
     testImplementation(libs.edc.core.junit)
 }
diff --git a/...ain/java/org/upm/inesdata/edc/extension/policy/ReferringConnectorValidationExtension.java b/...ain/java/org/upm/inesdata/edc/extension/policy/ReferringConnectorValidationExtension.java
@@ -1,11 +1,12 @@
 package org.upm.inesdata.edc.extension.policy;
 
+import org.eclipse.edc.connector.controlplane.catalog.spi.policy.CatalogPolicyContext;
+import org.eclipse.edc.connector.controlplane.contract.spi.policy.ContractNegotiationPolicyContext;
+import org.eclipse.edc.participant.spi.ParticipantAgentPolicyContext;
+import org.eclipse.edc.policy.engine.spi.AtomicConstraintRuleFunction;
 import org.upm.inesdata.edc.extension.policy.functions.ReferringConnectorDutyFunction;
 import org.upm.inesdata.edc.extension.policy.functions.ReferringConnectorPermissionFunction;
 import org.upm.inesdata.edc.extension.policy.functions.ReferringConnectorProhibitionFunction;
-import org.eclipse.edc.connector.controlplane.contract.spi.offer.ContractDefinitionResolver;
-import org.eclipse.edc.connector.controlplane.contract.spi.validation.ContractValidationService;
-import org.eclipse.edc.policy.engine.spi.AtomicConstraintFunction;
 import org.eclipse.edc.policy.engine.spi.PolicyEngine;
 import org.eclipse.edc.policy.engine.spi.RuleBindingRegistry;
 import org.eclipse.edc.policy.model.Duty;
@@ -15,8 +16,7 @@
 import org.eclipse.edc.runtime.metamodel.annotation.Inject;
 import org.eclipse.edc.spi.system.ServiceExtension;
 import org.eclipse.edc.spi.system.ServiceExtensionContext;
-
-import static org.eclipse.edc.policy.engine.spi.PolicyEngine.ALL_SCOPES;
+import org.eclipse.edc.policy.engine.spi.PolicyContext;
 
 public class ReferringConnectorValidationExtension implements ServiceExtension {
 
@@ -77,16 +77,16 @@ public String name() {
 
     @Override
     public void initialize(ServiceExtensionContext context) {
-        ruleBindingRegistry.bind(REFERRING_CONNECTOR_CONSTRAINT_KEY, ContractValidationService.NEGOTIATION_SCOPE);
-        ruleBindingRegistry.bind(REFERRING_CONNECTOR_CONSTRAINT_KEY, ContractDefinitionResolver.CATALOGING_SCOPE);
+        ruleBindingRegistry.bind(REFERRING_CONNECTOR_CONSTRAINT_KEY, ContractNegotiationPolicyContext.NEGOTIATION_SCOPE);
+        ruleBindingRegistry.bind(REFERRING_CONNECTOR_CONSTRAINT_KEY, CatalogPolicyContext.CATALOG_SCOPE);
 
         var monitor = context.getMonitor();
         registerPolicyFunction(Duty.class, new ReferringConnectorDutyFunction(monitor));
         registerPolicyFunction(Permission.class, new ReferringConnectorPermissionFunction(monitor));
         registerPolicyFunction(Prohibition.class, new ReferringConnectorProhibitionFunction(monitor));
     }
 
-    private <R extends Rule> void registerPolicyFunction(Class<R> type, AtomicConstraintFunction<R> function) {
-        policyEngine.registerFunction(ALL_SCOPES, type, REFERRING_CONNECTOR_CONSTRAINT_KEY, function);
+    private <R extends Rule, C extends PolicyContext> void registerPolicyFunction(Class<R> type, AtomicConstraintRuleFunction<R, C> function) {
+        policyEngine.registerFunction((Class<C>) ParticipantAgentPolicyContext.class, type, REFERRING_CONNECTOR_CONSTRAINT_KEY, function);
     }
 }
diff --git a/...org/upm/inesdata/edc/extension/policy/functions/AbstractReferringConnectorValidation.java b/...org/upm/inesdata/edc/extension/policy/functions/AbstractReferringConnectorValidation.java
@@ -1,8 +1,8 @@
 package org.upm.inesdata.edc.extension.policy.functions;
 
+import org.eclipse.edc.participant.spi.ParticipantAgentPolicyContext;
 import org.eclipse.edc.policy.engine.spi.PolicyContext;
 import org.eclipse.edc.policy.model.Operator;
-import org.eclipse.edc.spi.agent.ParticipantAgent;
 import org.eclipse.edc.spi.monitor.Monitor;
 
 import java.util.Arrays;
@@ -35,7 +35,7 @@ protected AbstractReferringConnectorValidation(Monitor monitor) {
      * @param policyContext context of the policy with claims
      * @return true if claims are from the constrained referring connector
      */
-    protected boolean evaluate(final Operator operator, final Object rightValue, final PolicyContext policyContext) {
+    protected boolean evaluate(final Operator operator, final Object rightValue, final ParticipantAgentPolicyContext policyContext) {
         if (policyContext.hasProblems() && !policyContext.getProblems().isEmpty()) {
             var problems = String.join(", ", policyContext.getProblems());
             var message =
@@ -46,7 +46,7 @@ protected boolean evaluate(final Operator operator, final Object rightValue, fin
             return false;
         }
 
-        final var claims = policyContext.getContextData(ParticipantAgent.class).getClaims();
+        final var claims = policyContext.participantAgent().getClaims();
 
         if (!claims.containsKey(REFERRING_CONNECTOR_CLAIM)) {
             return false;

diff --git a/.../java/org/upm/inesdata/edc/extension/policy/functions/ReferringConnectorDutyFunction.java b/.../java/org/upm/inesdata/edc/extension/policy/functions/ReferringConnectorDutyFunction.java
@@ -1,21 +1,32 @@
 package org.upm.inesdata.edc.extension.policy.functions;
 
-import org.eclipse.edc.policy.engine.spi.AtomicConstraintFunction;
-import org.eclipse.edc.policy.engine.spi.PolicyContext;
+import org.eclipse.edc.participant.spi.ParticipantAgentPolicyContext;
+import org.eclipse.edc.policy.engine.spi.AtomicConstraintRuleFunction;
 import org.eclipse.edc.policy.model.Duty;
 import org.eclipse.edc.policy.model.Operator;
 import org.eclipse.edc.spi.monitor.Monitor;
+import org.eclipse.edc.spi.result.Result;
 
 /** AtomicConstraintFunction to validate the referring connector claim for edc duties. */
 public class ReferringConnectorDutyFunction extends AbstractReferringConnectorValidation
-        implements AtomicConstraintFunction<Duty> {
+        implements AtomicConstraintRuleFunction<Duty, ParticipantAgentPolicyContext> {
 
     public ReferringConnectorDutyFunction(Monitor monitor) {
         super(monitor);
     }
 
     @Override
-    public boolean evaluate(Operator operator, Object rightValue, Duty rule, PolicyContext context) {
+    public boolean evaluate(Operator operator, Object rightValue, Duty rule, ParticipantAgentPolicyContext context) {
         return evaluate(operator, rightValue, context);
     }
+
+    @Override
+    public Result<Void> validate(Operator operator, Object rightValue, Duty rule) {
+        return AtomicConstraintRuleFunction.super.validate(operator, rightValue, rule);
+    }
+
+    @Override
+    public String name() {
+        return AtomicConstraintRuleFunction.super.name();
+    }
 }
diff --git a/...org/upm/inesdata/edc/extension/policy/functions/ReferringConnectorPermissionFunction.java b/...org/upm/inesdata/edc/extension/policy/functions/ReferringConnectorPermissionFunction.java
@@ -1,21 +1,32 @@
 package org.upm.inesdata.edc.extension.policy.functions;
 
-import org.eclipse.edc.policy.engine.spi.AtomicConstraintFunction;
-import org.eclipse.edc.policy.engine.spi.PolicyContext;
+import org.eclipse.edc.participant.spi.ParticipantAgentPolicyContext;
+import org.eclipse.edc.policy.engine.spi.AtomicConstraintRuleFunction;
 import org.eclipse.edc.policy.model.Operator;
 import org.eclipse.edc.policy.model.Permission;
 import org.eclipse.edc.spi.monitor.Monitor;
+import org.eclipse.edc.spi.result.Result;
 
 /** AtomicConstraintFunction to validate the referring connector claim for edc permissions. */
 public class ReferringConnectorPermissionFunction extends AbstractReferringConnectorValidation
-        implements AtomicConstraintFunction<Permission> {
+        implements AtomicConstraintRuleFunction<Permission, ParticipantAgentPolicyContext> {
 
     public ReferringConnectorPermissionFunction(Monitor monitor) {
         super(monitor);
     }
 
     @Override
-    public boolean evaluate(Operator operator, Object rightValue, Permission rule, PolicyContext context) {
+    public boolean evaluate(Operator operator, Object rightValue, Permission rule, ParticipantAgentPolicyContext context) {
         return evaluate(operator, rightValue, context);
     }
+
+    @Override
+    public Result<Void> validate(Operator operator, Object rightValue, Permission rule) {
+        return AtomicConstraintRuleFunction.super.validate(operator, rightValue, rule);
+    }
+
+    @Override
+    public String name() {
+        return AtomicConstraintRuleFunction.super.name();
+    }
 }
diff --git a/...rg/upm/inesdata/edc/extension/policy/functions/ReferringConnectorProhibitionFunction.java b/...rg/upm/inesdata/edc/extension/policy/functions/ReferringConnectorProhibitionFunction.java
@@ -1,21 +1,32 @@
 package org.upm.inesdata.edc.extension.policy.functions;
 
-import org.eclipse.edc.policy.engine.spi.AtomicConstraintFunction;
-import org.eclipse.edc.policy.engine.spi.PolicyContext;
+import org.eclipse.edc.participant.spi.ParticipantAgentPolicyContext;
+import org.eclipse.edc.policy.engine.spi.AtomicConstraintRuleFunction;
 import org.eclipse.edc.policy.model.Operator;
 import org.eclipse.edc.policy.model.Prohibition;
 import org.eclipse.edc.spi.monitor.Monitor;
+import org.eclipse.edc.spi.result.Result;
 
 /** AtomicConstraintFunction to validate the referring connector claim  edc prohibitions. */
 public class ReferringConnectorProhibitionFunction extends AbstractReferringConnectorValidation
-        implements AtomicConstraintFunction<Prohibition> {
+        implements AtomicConstraintRuleFunction<Prohibition, ParticipantAgentPolicyContext> {
 
     public ReferringConnectorProhibitionFunction(Monitor monitor) {
         super(monitor);
     }
 
     @Override
-    public boolean evaluate(Operator operator, Object rightValue, Prohibition rule, PolicyContext context) {
+    public boolean evaluate(Operator operator, Object rightValue, Prohibition rule, ParticipantAgentPolicyContext context) {
         return evaluate(operator, rightValue, context);
     }
+
+    @Override
+    public Result<Void> validate(Operator operator, Object rightValue, Prohibition rule) {
+        return AtomicConstraintRuleFunction.super.validate(operator, rightValue, rule);
+    }
+
+    @Override
+    public String name() {
+        return AtomicConstraintRuleFunction.super.name();
+    }
 }
diff --git a/...al/src/main/java/org/upm/inesdata/edc/extension/policy/PolicyEvaluationTimeExtension.java b/...al/src/main/java/org/upm/inesdata/edc/extension/policy/PolicyEvaluationTimeExtension.java
@@ -14,6 +14,7 @@
 
 package org.upm.inesdata.edc.extension.policy;
 
+import org.eclipse.edc.policy.engine.spi.PolicyContext;
 import org.eclipse.edc.policy.engine.spi.PolicyEngine;
 import org.eclipse.edc.policy.engine.spi.RuleBindingRegistry;
 import org.eclipse.edc.policy.model.Permission;
@@ -46,7 +47,7 @@ public void initialize(ServiceExtensionContext context) {
         ruleBindingRegistry.bind("USE", ALL_SCOPES);
         ruleBindingRegistry.bind(KEY_POLICY_EVALUATION_TIME, ALL_SCOPES);
         policyEngine.registerFunction(
-                ALL_SCOPES,
+                PolicyContext.class,
                 Permission.class,
                 KEY_POLICY_EVALUATION_TIME,
                 new PolicyEvaluationTimeFunction(monitor));

diff --git a/.../main/java/org/upm/inesdata/api/shared/configuration/SharedApiConfigurationExtension.java b/.../main/java/org/upm/inesdata/api/shared/configuration/SharedApiConfigurationExtension.java
@@ -26,8 +26,10 @@
 import java.net.URI;
 
 import static java.lang.String.format;
+import static org.eclipse.edc.jsonld.spi.JsonLdKeywords.VOCAB;
 import static org.eclipse.edc.policy.model.OdrlNamespace.ODRL_PREFIX;
 import static org.eclipse.edc.policy.model.OdrlNamespace.ODRL_SCHEMA;
+import static org.eclipse.edc.spi.constants.CoreConstants.EDC_NAMESPACE;
 import static org.eclipse.edc.spi.constants.CoreConstants.JSON_LD;
 
 /**
@@ -93,6 +95,7 @@ public void initialize(ServiceExtensionContext context) {
         webService.registerResource("shared", authenticationFilter);
 
         jsonLd.registerNamespace(ODRL_PREFIX, ODRL_SCHEMA, SHARED_SCOPE);
+        jsonLd.registerNamespace(VOCAB, EDC_NAMESPACE, SHARED_SCOPE);
         var jsonLdMapper = typeManager.getMapper(JSON_LD);
         webService.registerResource("shared", new ObjectMapperProvider(jsonLdMapper));
         webService.registerResource("shared", new JerseyJsonLdInterceptor(jsonLd, jsonLdMapper, SHARED_SCOPE));

diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
@@ -3,8 +3,8 @@ format.version = "1.1"
 
 [versions]
 awaitility = "4.2.2"
-edc = "0.9.1"
-jupiter = "5.11.0"
+edc = "0.10.1"
+jupiter = "5.11.3"
 restAssured = "5.5.0"
 rsApi = "4.0.0"
 
@@ -18,7 +18,7 @@ lombok = "1.18.30"
 parsson = "1.1.6"
 rseeApi = "10.0.0"
 jersey = "3.1.8"
-aws = "2.26.7"
+aws = "2.29.1"
 
 
 [libraries]
@@ -75,14 +75,18 @@ restAssured = { module = "io.rest-assured:rest-assured", version.ref = "restAssu
 azure-storage-blob = { module = "com.azure:azure-storage-blob", version = "12.27.1" }
 minio-io = { module = "io.minio:minio", version = "8.5.12" }
 
+edc-core-token = { module = "org.eclipse.edc:token-core", version.ref = "edc" }
+edc-spi-jwt = { module = "org.eclipse.edc:jwt-spi", version.ref = "edc" }
 edc-auth-spi = { module = "org.eclipse.edc:auth-spi", version.ref = "edc" }
 edc-iam-oauth2-core = { module = "org.eclipse.edc:oauth2-core", version.ref = "edc" }
 edc-iam-oauth2-service = { module = "org.eclipse.edc:oauth2-service", version.ref = "edc"}
 assertj = { module = "org.assertj:assertj-core", version.ref = "assertj" }
 mockito-core = { module = "org.mockito:mockito-core", version.ref = "mockito" }
 edc-core-junit = { module = "org.eclipse.edc:junit", version.ref = "edc" }
+edc-catalog-spi = { module = "org.eclipse.edc:catalog-spi", version.ref = "edc" }
 edc-contract-spi = { module = "org.eclipse.edc:contract-spi", version.ref = "edc" }
 edc-transfer-spi = { module = "org.eclipse.edc:transfer-spi", version.ref = "edc" }
+edc-participant-spi = { module = "org.eclipse.edc:participant-spi", version.ref = "edc" }
 
 # EDC Federated Catalog
 edc-federated-catalog-api = { module = "org.eclipse.edc:federated-catalog-api", version.ref = "edc" }

diff --git a/launchers/connector/build.gradle.kts b/launchers/connector/build.gradle.kts
@@ -42,6 +42,8 @@ dependencies {
     // IAM Identity and authorization
     implementation(libs.edc.iam.oauth2.service)
     implementation(project(":extensions:auth-oauth2-jwt"))
+    implementation(libs.edc.core.token)
+    implementation(libs.edc.spi.jwt)
     // Secretos
     implementation(libs.edc.vault.hashicorp)
     // Federated Catalog