policy not evaluated

[ghost]

Hi,
I have two rules in my policy. A location and time constraint, but only the location constraint is evaluated. How can I also evaluate my time constraint?
Here is my time constraint function:

package org.eclipse.edc.sample.extension.policy;


import org.eclipse.edc.policy.engine.spi.AtomicConstraintFunction;
import org.eclipse.edc.policy.model.Operator;
import org.eclipse.edc.policy.model.Permission;
import org.eclipse.edc.policy.engine.spi.PolicyContext;
import org.eclipse.edc.spi.monitor.Monitor;

import java.time.Duration;
import java.time.OffsetDateTime;

public class TimeConstraintFunction implements AtomicConstraintFunction<Permission> {

    private final Monitor monitor;
    private final OffsetDateTime creationTimestamp;

    public TimeConstraintFunction(Monitor monitor, OffsetDateTime creationTimestamp) {
        this.monitor = monitor;
        this.creationTimestamp = creationTimestamp;
    }

    @Override
    public boolean evaluate(Operator operator, Object rightValue, Permission permission, PolicyContext context) {
        if (!(rightValue instanceof String durationString)) {
            monitor.warning("Invalid duration value: " + rightValue);
            return false;
        }

        try {
            Duration duration = Duration.parse(durationString);
            OffsetDateTime currentTime = OffsetDateTime.now();

            // Calculate the elapsed time since the start time (creation timestamp)
            Duration elapsedTime = Duration.between(creationTimestamp, currentTime);

            // Compare the elapsed time with the specified duration
            boolean result;
            switch (operator.name()) {
                case "LT": // Less Than
                    result = elapsedTime.compareTo(duration) < 0;
                    if (result) {
                        monitor.info("Time constraint evaluation successful: Elapsed time is less than specified duration.");
                    }
                    return result;
                case "GT": // Greater Than
                    result = elapsedTime.compareTo(duration) > 0;
                    if (result) {
                        monitor.info("Time constraint evaluation successful: Elapsed time is greater than specified duration.");
                    }
                    return result;
                default:
                    monitor.warning("Unsupported operator: " + operator.name());
                    return false;
            }
        } catch (Exception e) {
            monitor.warning("Error parsing time constraint value: " + e.getMessage());
            return false;
        }
    }
}

and policy function extension:

/*
 *  Copyright (c) 2024 Fraunhofer Institute for Software and Systems Engineering
 *
 *  This program and the accompanying materials are made available under the
 *  terms of the Apache License, Version 2.0 which is available at
 *  https://www.apache.org/licenses/LICENSE-2.0
 *
 *  SPDX-License-Identifier: Apache-2.0
 *
 *  Contributors:
 *       Fraunhofer Institute for Software and Systems Engineering - initial API and implementation
 *
 */

package org.eclipse.edc.sample.extension.policy;

import org.eclipse.edc.policy.engine.spi.PolicyEngine;
import org.eclipse.edc.policy.engine.spi.RuleBindingRegistry;
import org.eclipse.edc.policy.model.Permission;
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.connector.contract.spi.validation.ContractValidationService.NEGOTIATION_SCOPE;
import static org.eclipse.edc.jsonld.spi.PropertyAndTypeNames.ODRL_USE_ACTION_ATTRIBUTE;
import static org.eclipse.edc.policy.engine.spi.PolicyEngine.ALL_SCOPES;
import static org.eclipse.edc.spi.CoreConstants.EDC_NAMESPACE;

import java.time.OffsetDateTime;

public class PolicyFunctionsExtension implements ServiceExtension {
    private static final String LOCATION_CONSTRAINT_KEY = EDC_NAMESPACE + "location";
    private static final String TIME_LIMIT_CONSTRAINT_KEY = EDC_NAMESPACE + "elapsedTime";

    @Inject
    private RuleBindingRegistry ruleBindingRegistry;
    @Inject
    private PolicyEngine policyEngine;

    @Override
    public String name() {
        return "eu and time policy functions";
    }

    @Override
    public void initialize(ServiceExtensionContext context) {
        var monitor = context.getMonitor();
        OffsetDateTime creationTimestamp = OffsetDateTime.now();

        ruleBindingRegistry.bind(ODRL_USE_ACTION_ATTRIBUTE, ALL_SCOPES);
        ruleBindingRegistry.bind(LOCATION_CONSTRAINT_KEY, NEGOTIATION_SCOPE);
        policyEngine.registerFunction(ALL_SCOPES, Permission.class, LOCATION_CONSTRAINT_KEY, new LocationConstraintFunction(monitor));

        ruleBindingRegistry.bind(TIME_LIMIT_CONSTRAINT_KEY, NEGOTIATION_SCOPE);
        // Pass both monitor and creationTimestamp to TimeConstraintFunction constructor
        policyEngine.registerFunction(ALL_SCOPES, Permission.class, TIME_LIMIT_CONSTRAINT_KEY,
                new TimeConstraintFunction(monitor, creationTimestamp));
    }
}

Thanks in advance

[ndr-brt]

is this question related to the samples? which one? could you give the full example (e.g. the policy used) with which you encountered the issue?

[ghost]

Now the time constraint is evaluated. I had to restart IntelliJ.
But my time constraint does not really work. Data consumers are only allowed to use the data within 15 min after negotiation. However, after that time they can still use it. Is my time constraint not defined correctly?

[ndr-brt]

I think the issue was that the code was not compiled correctly.

Please note that in your code creationTimestamp is instantiated when the connector starts, not when the negotiation is agreed upon. You can get the ContractAgreement instance out of the PolicyContext to get that date.

[ghost]

Do you mean it like this?

OffsetDateTime negotiationTimestamp = context.getContractAgreement().getNegotiationTime();  
        policyEngine.registerFunction(NEGOTIATION_SCOPE, Permission.class, TIME_LIMIT_CONSTRAINT_KEY,
                new TimeConstraintFunction(context.getMonitor(), negotiationTimestamp));

I passed PolicyContext to TimeConstraintFunction, however there is no method like getNegotiationTime()

[ndr-brt]

the agreement cannot be fetched at extension initialization time, you need to get the agreement IN the policy function out of the PolicyContext object

[ghost]

in my code the creationTimestamp is instantiated when the connector starts. I get the authorization key to access the data set after a successful negotiation. But when executing the get request with the authorization key even after 15min, I can still see my data set. However, I want to cut the access after 15min. That after executing the get request with the authorization key after 15min, I wont be able to see the data set anymore. (see https://github.com/eclipse-edc/Samples/tree/main/transfer/transfer-02-consumer-pull#4-check-the-data)
can I achieve the termination of the contract agreement like this:

package org.eclipse.edc.sample.extension.policy;

import org.eclipse.edc.connector.contract.spi.ContractAgreement;
import org.eclipse.edc.policy.engine.spi.AtomicConstraintFunction;
import org.eclipse.edc.policy.model.Operator;
import org.eclipse.edc.policy.model.Permission;
import org.eclipse.edc.policy.engine.spi.PolicyContext;
import org.eclipse.edc.spi.monitor.Monitor;

import java.time.Duration;
import java.time.OffsetDateTime;

public class TimeConstraintFunction implements AtomicConstraintFunction<Permission> {

    private final Monitor monitor;
    private final OffsetDateTime agreementStartDate;

    public TimeConstraintFunction(Monitor monitor, OffsetDateTime agreementStartDate) {
        this.monitor = monitor;
        this.agreementStartDate = agreementStartDate;
    }

    @Override
    public boolean evaluate(Operator operator, Object rightValue, Permission permission, PolicyContext context) {
        monitor.info("Evaluating time constraint...");

        try {
            Duration duration = Duration.parse((String) rightValue);
            OffsetDateTime currentTime = OffsetDateTime.now();

            // Calculate the elapsed time since the agreement start date
            Duration elapsedTime = Duration.between(agreementStartDate, currentTime);

            // Compare the elapsed time with the specified duration
            boolean result;
            switch (operator.name()) {
                case "LT": // Less Than
                    result = elapsedTime.compareTo(duration) < 0;
                    if (!result) {
                        // Access the contract agreement
                        ContractAgreement contractAgreement = context.getContractAgreement();
                        // Terminate the agreement if elapsed time exceeds 15 minutes
                        contractAgreement.terminate();
                        monitor.info("Contract agreement terminated due to elapsed time exceeding 15 minutes.");
                    }
                    return result;
                default:
                    monitor.warning("Unsupported operator: " + operator.name());
                    return false;
            }
        } catch (Exception e) {
            monitor.warning("Error parsing time constraint value: " + e.getMessage());
            return false;
        }
    }
}

but here I dont have this import org.eclipse.edc.connector.contract.spi.ContractAgreement;