From 04c5e9f375119a8c53954743aab606fc5c5ebf22 Mon Sep 17 00:00:00 2001 From: Eric Bariaux <375613+ebariaux@users.noreply.github.com> Date: Wed, 18 Mar 2026 11:45:30 +0100 Subject: [PATCH 01/13] Set-up to make running tests in extensions repo work --- project.gradle | 5 +++++ test-support/manager-app/index.html | 10 ++++++++++ 2 files changed, 15 insertions(+) create mode 100644 test-support/manager-app/index.html diff --git a/project.gradle b/project.gradle index cca9830..8e2f64d 100644 --- a/project.gradle +++ b/project.gradle @@ -143,6 +143,11 @@ plugins.withType(JavaPlugin).whenPluginAdded { test { workingDir = findProject(":openremote") != null ? project(":openremote").projectDir : rootProject.projectDir + if (findProject(":openremote") == null) { + // Extension-only repos don't ship the manager UI tree expected by ManagerWebService. + // Point tests at a minimal placeholder docroot so container startup still succeeds. + environment "OR_APP_DOCROOT", rootProject.file("test-support/manager-app").absolutePath + } useJUnitPlatform() testLogging { // set options for log level LIFECYCLE diff --git a/test-support/manager-app/index.html b/test-support/manager-app/index.html new file mode 100644 index 0000000..6dfee5b --- /dev/null +++ b/test-support/manager-app/index.html @@ -0,0 +1,10 @@ + + + + + OpenRemote Test Manager App + + + Test manager app placeholder. + + From 745d1a46587f2570b3c0f7b9cfddf266e08cd0f9 Mon Sep 17 00:00:00 2001 From: Eric Bariaux <375613+ebariaux@users.noreply.github.com> Date: Wed, 18 Mar 2026 11:46:00 +0100 Subject: [PATCH 02/13] Implement an ENTSO-E agent --- entsoe/build.gradle | 87 ++ .../entsoe/agent/protocol/EntsoeAgent.java | 50 + .../agent/protocol/EntsoeAgentLink.java | 30 + .../protocol/EntsoeAgentModelProvider.java | 11 + .../entsoe/agent/protocol/EntsoeProtocol.java | 382 ++++++++ .../protocol/PublicationMarketDocument.java | 77 ++ .../org.openremote.model.AssetModelProvider | 1 + .../agent/protocol/EntsoeProtocolTest.groovy | 883 ++++++++++++++++++ 8 files changed, 1521 insertions(+) create mode 100644 entsoe/build.gradle create mode 100644 entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeAgent.java create mode 100644 entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeAgentLink.java create mode 100644 entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeAgentModelProvider.java create mode 100644 entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java create mode 100644 entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/PublicationMarketDocument.java create mode 100644 entsoe/src/main/resources/META-INF/services/org.openremote.model.AssetModelProvider create mode 100644 entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy diff --git a/entsoe/build.gradle b/entsoe/build.gradle new file mode 100644 index 0000000..d86e579 --- /dev/null +++ b/entsoe/build.gradle @@ -0,0 +1,87 @@ +apply plugin: "groovy" +apply plugin: "java-library" +apply plugin: "maven-publish" +apply plugin: "signing" + +base { + archivesName = "openremote-${project.name}-extension" +} + +dependencies { + api "io.openremote:openremote-manager:$openremoteVersion" + api "io.openremote:openremote-model:$openremoteVersion" + + api "org.jboss.resteasy:resteasy-client-api:$resteasyVersion" + api "org.jboss.resteasy:resteasy-jaxb-provider:$resteasyVersion" + + testImplementation "io.openremote:openremote-test:$openremoteVersion" +} + +jar { + from sourceSets.main.allJava +} + +javadoc { + failOnError = false +} + +java { + withJavadocJar() + withSourcesJar() +} + +publishing { + publications { + maven(MavenPublication) { + group = "io.openremote.extension" + artifactId = "openremote-${project.name}-extension" + from components.java + pom { + name = 'OpenRemote ENTSO-E extension' + description = 'Adds the ENTSO-E extension' + url = 'https://github.com/openremote/extensions' + licenses { + license { + name = 'GNU Affero General Public License v3.0' + url = 'https://www.gnu.org/licenses/agpl-3.0.en.html' + } + } + developers { + developer { + id = 'developers' + name = 'Developers' + email = 'developers@openremote.io' + organization = 'OpenRemote' + organizationUrl = 'https://openremote.io' + } + } + scm { + connection = 'scm:git:git://github.com/openremote/extensions.git' + developerConnection = 'scm:git:ssh://github.com:openremote/extensions.git' + url = 'https://github.com/openremote/extensions/tree/main' + } + } + } + } + + repositories { + maven { + if (!version.endsWith('-LOCAL')) { + credentials { + username = findProperty("publishUsername") + password = findProperty("publishPassword") + } + } + url = version.endsWith('-LOCAL') ? layout.buildDirectory.dir('repo') : version.endsWith('-SNAPSHOT') ? findProperty("snapshotsRepoUrl") : findProperty("releasesRepoUrl") + } + } +} + +signing { + def signingKey = findProperty("signingKey") + def signingPassword = findProperty("signingPassword") + if (signingKey && signingPassword) { + useInMemoryPgpKeys(signingKey, signingPassword) + sign publishing.publications.maven + } +} diff --git a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeAgent.java b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeAgent.java new file mode 100644 index 0000000..7312e45 --- /dev/null +++ b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeAgent.java @@ -0,0 +1,50 @@ +package org.openremote.extension.entsoe.agent.protocol; + +import jakarta.persistence.Entity; +import org.openremote.model.asset.agent.Agent; +import org.openremote.model.asset.agent.AgentDescriptor; +import org.openremote.model.value.AttributeDescriptor; +import org.openremote.model.value.ValueType; + +import java.util.Optional; + +@Entity +public class EntsoeAgent extends Agent { + + public static final AgentDescriptor DESCRIPTOR = new AgentDescriptor<>( + EntsoeAgent.class, EntsoeProtocol.class, EntsoeAgentLink.class); + + public static final AttributeDescriptor SECURITY_TOKEN = new AttributeDescriptor<>("securityToken", ValueType.TEXT); + + public static final AttributeDescriptor BASE_URL = new AttributeDescriptor<>("baseURL", ValueType.TEXT).withOptional(true); + + public EntsoeAgent() { + } + + public EntsoeAgent(String name) { + super(name); + } + + @Override + public EntsoeProtocol getProtocolInstance() { + return new EntsoeProtocol(this); + } + + public Optional getSecurityToken() { + return getAttributes().getValue(SECURITY_TOKEN); + } + + public EntsoeAgent setSecurityToken(String value) { + getAttributes().getOrCreate(SECURITY_TOKEN).setValue(value); + return this; + } + + public Optional getBaseURL() { + return getAttributes().getValue(BASE_URL); + } + + public EntsoeAgent setBaseURL(String value) { + getAttributes().getOrCreate(BASE_URL).setValue(value); + return this; + } +} diff --git a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeAgentLink.java b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeAgentLink.java new file mode 100644 index 0000000..624e3b5 --- /dev/null +++ b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeAgentLink.java @@ -0,0 +1,30 @@ +package org.openremote.extension.entsoe.agent.protocol; + +import com.fasterxml.jackson.annotation.JsonPropertyDescription; +import jakarta.validation.constraints.NotNull; +import jakarta.validation.constraints.Pattern; +import org.openremote.model.asset.agent.AgentLink; + +public class EntsoeAgentLink extends AgentLink { + + @NotNull + @JsonPropertyDescription("Energy Identification Code of zone to fetch data for") + @Pattern(regexp = "^\\d{2}[A-Z][A-Z0-9-]{12}[A-Z0-9]$") + private String zone; + + // For Hydrators + public EntsoeAgentLink() { + } + + public EntsoeAgentLink(String id) { + super(id); + } + + public String getZone() { + return zone; + } + + public void setZone(String zone) { + this.zone = zone; + } +} diff --git a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeAgentModelProvider.java b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeAgentModelProvider.java new file mode 100644 index 0000000..278e36b --- /dev/null +++ b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeAgentModelProvider.java @@ -0,0 +1,11 @@ +package org.openremote.extension.entsoe.agent.protocol; + +import org.openremote.model.AssetModelProvider; + +public class EntsoeAgentModelProvider implements AssetModelProvider { + + @Override + public boolean useAutoScan() { + return true; + } +} diff --git a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java new file mode 100644 index 0000000..aac6b79 --- /dev/null +++ b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java @@ -0,0 +1,382 @@ +package org.openremote.extension.entsoe.agent.protocol; + +import jakarta.ws.rs.core.Response; +import jakarta.ws.rs.core.UriBuilder; +import jakarta.xml.bind.JAXBContext; +import jakarta.xml.bind.Unmarshaller; +import org.jboss.resteasy.client.jaxrs.ResteasyClient; +import org.openremote.agent.protocol.AbstractProtocol; +import org.openremote.model.Container; +import org.openremote.model.asset.agent.ConnectionStatus; +import org.openremote.model.attribute.Attribute; +import org.openremote.model.attribute.AttributeEvent; +import org.openremote.model.attribute.AttributeRef; +import org.openremote.model.datapoint.ValueDatapoint; +import org.openremote.model.syslog.SyslogCategory; + +import javax.xml.stream.XMLInputFactory; +import javax.xml.stream.XMLStreamConstants; +import javax.xml.stream.XMLStreamReader; +import java.io.StringReader; +import java.math.BigDecimal; +import java.time.Duration; +import java.time.Instant; +import java.time.OffsetDateTime; +import java.time.ZoneId; +import java.time.format.DateTimeFormatter; +import java.time.format.DateTimeFormatterBuilder; +import java.time.temporal.ChronoUnit; +import java.util.ArrayList; +import java.util.Comparator; +import java.util.List; +import java.util.concurrent.ScheduledFuture; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicReference; +import java.util.logging.Level; +import java.util.logging.Logger; + +import static org.openremote.container.web.WebTargetBuilder.createClient; +import static org.openremote.model.syslog.SyslogCategory.PROTOCOL; + +public class EntsoeProtocol extends AbstractProtocol { + + private static final Logger LOG = SyslogCategory.getLogger(PROTOCOL, EntsoeProtocol.class); + private static final DateTimeFormatter PERIOD_FORMATTER = DateTimeFormatter.ofPattern("yyyyMMddHHmm").withZone(ZoneId.of("UTC")); + private static final DateTimeFormatter ENTSOE_DATETIME_FORMATTER = new DateTimeFormatterBuilder() + .appendPattern("yyyy-MM-dd'T'HH:mm") + .optionalStart().appendPattern(":ss").optionalEnd() + .appendOffsetId() + .toFormatter(); + public static final String PROTOCOL_DISPLAY_NAME = "ENTSO-E"; + private static final AtomicReference client = new AtomicReference<>(); + private static final JAXBContext PUBLICATION_MARKET_DOCUMENT_CONTEXT = createPublicationMarketDocumentContext(); + private static final ThreadLocal PUBLICATION_UNMARSHALLER = ThreadLocal.withInitial(EntsoeProtocol::createPublicationUnmarshaller); + private static final ThreadLocal XML_INPUT_FACTORY = ThreadLocal.withInitial(XMLInputFactory::newFactory); + + // Initial delay to allow system to populate agent links + private static final int INITIAL_POLLING_DELAY_MILLIS = 3000; // 3 seconds + private static final int DEFAULT_POLLING_MILLIS = 3600000; // 1 hour + + protected ScheduledFuture pollingFuture; + + public EntsoeProtocol(EntsoeAgent agent) { + super(agent); + initClient(); + } + + @Override + protected void doStart(Container container) throws Exception { + setConnectionStatus(ConnectionStatus.CONNECTING); + + if (agent.getSecurityToken().isEmpty()) { + setConnectionStatus(ConnectionStatus.ERROR); + LOG.warning("Security token is not set"); + return; + } + + if (!healthCheck()) { + setConnectionStatus(ConnectionStatus.ERROR); + LOG.warning("Could not reach ENTSO-E API, either API is unavailable or security token is invalid"); + return; + } + + restartPollingWithInitialDelay(); + + setConnectionStatus(ConnectionStatus.CONNECTED); + } + + @Override + protected void doStop(Container container) throws Exception { + // Cancel the polling task + if (pollingFuture != null) { + pollingFuture.cancel(true); + } + } + + @Override + protected void doLinkAttribute(String assetId, Attribute attribute, EntsoeAgentLink agentLink) throws RuntimeException { + if (!attribute.getType().getType().isAssignableFrom(BigDecimal.class) && !attribute.getType().getType().isAssignableFrom(Double.class)) { + LOG.warning("Linked attribute " + attribute.getName() + " of asset " + assetId + " not of supported type. Predicted data points will still be generated but inconsistent behaviour could occur."); + } + restartPollingWithInitialDelay(); + } + + @Override + protected void doUnlinkAttribute(String assetId, Attribute attribute, EntsoeAgentLink agentLink) { + // Do nothing, attributes that have been unlinked will not be processed anymore when we next trigger + } + + protected synchronized void restartPollingWithInitialDelay() { + if (scheduledExecutorService == null) { + return; + } + + if (pollingFuture != null) { + pollingFuture.cancel(false); + } + + int pollingMillis = agent.getPollingMillis().orElse(DEFAULT_POLLING_MILLIS); + pollingFuture = scheduledExecutorService.scheduleAtFixedRate( + this::updateAllLinkedAttributes, + INITIAL_POLLING_DELAY_MILLIS, + pollingMillis, + TimeUnit.MILLISECONDS + ); + } + + @Override + protected void doLinkedAttributeWrite(EntsoeAgentLink agentLink, AttributeEvent event, Object processedValue) { + // If some external source wants to write the current value of the attribute, we're OK with that + // and relay the event with AgentService as source so it goes through. + assetService.sendAttributeEvent(event); + } + + @Override + public String getProtocolName() { + return PROTOCOL_DISPLAY_NAME; + } + + @Override + public String getProtocolInstanceUri() { + return "https://transparency.entsoe.eu/"; + } + + protected void updateAllLinkedAttributes() { + LOG.fine("Updating all linked attributes with pricing information from ENTSO-E"); + + if (getLinkedAttributes().isEmpty()) { + LOG.fine("No linked attributes found, skipping pricing data update"); + return; + } + + getLinkedAttributes().forEach(this::updatePricingInformation); + } + + protected void updatePricingInformation(AttributeRef attributeRefs, Attribute attribute) { + LOG.fine("Updating pricing information data for attribute " + attribute.getName()); + + EntsoeAgentLink agentLink = agent.getAgentLink(attribute); + + PublicationMarketDocument doc = fetchPricingInformation(buildApiUrl(agentLink.getZone())); + if (doc == null) { + LOG.warning(() -> "No ENTSO-E publication document returned for attribute: " + attributeRefs); + return; + } + + List> predictedDatapoints = buildPredictedDatapoints(doc); + if (predictedDatapoints.isEmpty()) { + LOG.warning(() -> "No datapoints built from ENTSO-E publication document for attribute: " + attributeRefs); + return; + } + + predictedDatapointService.updateValues(attributeRefs.getId(), attributeRefs.getName(), predictedDatapoints); + + } + + protected String buildApiUrl(String zone) { + String securityToken = agent.getSecurityToken().orElseThrow(() -> new IllegalStateException("Security token is not set")); + String baseUrl = agent.getBaseURL().orElse("https://web-api.tp.entsoe.eu/api"); + Instant start = timerService.getNow(); + Instant end = start.plus(1, ChronoUnit.DAYS); + + return UriBuilder.fromUri(baseUrl) + .queryParam("documentType", "A44") + .queryParam("contract_MarketAgreement.type", "A01") + .queryParam("periodStart", PERIOD_FORMATTER.format(start)) + .queryParam("periodEnd", PERIOD_FORMATTER.format(end)) + .queryParam("in_Domain", zone) + .queryParam("out_Domain", zone) + .queryParam("securityToken", securityToken) + .build() + .toString(); + } + + /** + * Perform a health check by sending a request to the ENTSO-E API + * + * @return true if the health check is successful, false otherwise + */ + protected boolean healthCheck() { + String apiUrl = buildApiUrl("10YBE----------2"); + try (Response response = client.get().target(apiUrl).request(javax.ws.rs.core.MediaType.APPLICATION_XML).get()) { + if (response.getStatus() != 200) { + LOG.warning("Health check failed with status: " + response.getStatus()); + return false; + } else { + return true; + } + } catch (Exception e) { + LOG.log(Level.WARNING, e, () -> "Failed to perform health check"); + return false; + } + } + + /** + * Fetch the pricing data from the ENTSO-E API for the given API URL + * + * @param apiUrl the API URL + * @return the PublicationMarketDocument from the API + */ + protected PublicationMarketDocument fetchPricingInformation(String apiUrl) { + try (Response response = client.get().target(apiUrl).request(javax.ws.rs.core.MediaType.APPLICATION_XML).get()) { + if (response.getStatus() == 200) { + String responseXml = response.readEntity(String.class); + EntsoeXmlMeta xmlMeta = parseEntsoeXmlMeta(responseXml); + + if ("Publication_MarketDocument".equals(xmlMeta.rootElement)) { + return (PublicationMarketDocument) PUBLICATION_UNMARSHALLER.get().unmarshal(new StringReader(responseXml)); + } + + if ("Acknowledgement_MarketDocument".equals(xmlMeta.rootElement)) { + String reason = xmlMeta.reasonText != null ? xmlMeta.reasonText : "no reason provided"; + LOG.info("No ENTSO-E pricing data available: " + reason); + return null; + } + + LOG.warning("Unsupported ENTSO-E response XML root element: " + xmlMeta.rootElement); + return null; + } else if (response.getStatus() == 401) { + LOG.warning("API request was unauthorized, either the security token is invalid or does not provide access to the API"); + return null; + } else { + LOG.warning("API request failed with status: " + response.getStatus()); + return null; + } + } catch (Exception e) { + LOG.log(Level.WARNING, e, () -> "Failed to fetch pricing data"); + return null; + } + } + + protected static JAXBContext createPublicationMarketDocumentContext() { + try { + return JAXBContext.newInstance(PublicationMarketDocument.class); + } catch (Exception e) { + throw new IllegalStateException("Failed to initialise PublicationMarketDocument JAXB context", e); + } + } + + protected static Unmarshaller createPublicationUnmarshaller() { + try { + return PUBLICATION_MARKET_DOCUMENT_CONTEXT.createUnmarshaller(); + } catch (Exception e) { + throw new IllegalStateException("Failed to initialise PublicationMarketDocument unmarshaller", e); + } + } + + protected EntsoeXmlMeta parseEntsoeXmlMeta(String xml) throws Exception { + XMLStreamReader reader = XML_INPUT_FACTORY.get().createXMLStreamReader(new StringReader(xml)); + String rootElement = null; + String reasonText = null; + boolean inReason = false; + boolean inReasonText = false; + + try { + while (reader.hasNext()) { + int event = reader.next(); + + if (event == XMLStreamConstants.START_ELEMENT) { + String localName = reader.getLocalName(); + if (rootElement == null) { + rootElement = localName; + } + if ("Reason".equals(localName)) { + inReason = true; + } else if (inReason && "text".equals(localName)) { + inReasonText = true; + } + } else if (event == XMLStreamConstants.CHARACTERS && inReasonText) { + String text = reader.getText(); + if (text != null && !text.isBlank()) { + reasonText = reasonText == null ? text.trim() : reasonText + text.trim(); + } + } else if (event == XMLStreamConstants.END_ELEMENT) { + String localName = reader.getLocalName(); + if ("text".equals(localName)) { + inReasonText = false; + } else if ("Reason".equals(localName)) { + inReason = false; + } + } + } + } finally { + reader.close(); + } + + return new EntsoeXmlMeta(rootElement, reasonText); + } + + protected static class EntsoeXmlMeta { + protected final String rootElement; + protected final String reasonText; + + protected EntsoeXmlMeta(String rootElement, String reasonText) { + this.rootElement = rootElement; + this.reasonText = reasonText; + } + } + + protected List> buildPredictedDatapoints(PublicationMarketDocument document) { + List> values = new ArrayList<>(); + long nowMillis = timerService.getCurrentTimeMillis(); + if (document.getTimeSeries() == null || document.getTimeSeries().isEmpty()) { + return values; + } + + for (PublicationMarketDocument.TimeSeries timeSeries : document.getTimeSeries()) { + PublicationMarketDocument.Period period = timeSeries.getPeriod(); + if (period == null || period.getPoints() == null || period.getPoints().isEmpty()) { + continue; + } + + PublicationMarketDocument.PeriodTimeInterval timeInterval = period.getTimeInterval() != null + ? period.getTimeInterval() + : document.getPeriodTimeInterval(); + if (timeInterval == null || timeInterval.getStart() == null || period.getResolution() == null) { + continue; + } + + final Instant start; + final Duration resolution; + try { + start = parseEntsoeInstant(timeInterval.getStart()); + resolution = Duration.parse(period.getResolution()); + } catch (Exception e) { + LOG.log(Level.WARNING, e, () -> "Could not parse ENTSO-E timeseries time data"); + continue; + } + + period.getPoints().stream() + .filter(point -> point.getPosition() != null && point.getPosition() > 0 && point.getPriceAmount() != null) + .sorted(Comparator.comparingInt(PublicationMarketDocument.Point::getPosition)) + .forEach(point -> { + long timestamp = start + .plus(resolution.multipliedBy(point.getPosition() - 1L)) + .toEpochMilli(); + if (timestamp >= nowMillis) { + values.add(new ValueDatapoint<>(timestamp, point.getPriceAmount())); + } + }); + } + + values.sort(Comparator.comparingLong(ValueDatapoint::getTimestamp)); + return values; + } + + protected Instant parseEntsoeInstant(String value) { + try { + return Instant.parse(value); + } catch (Exception ignored) { + return OffsetDateTime.parse(value, ENTSOE_DATETIME_FORMATTER).toInstant(); + } + } + + protected static void initClient() { + synchronized (client) { + if (client.get() == null) { + client.set(createClient(org.openremote.container.Container.SCHEDULED_EXECUTOR)); + } + } + } + +} diff --git a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/PublicationMarketDocument.java b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/PublicationMarketDocument.java new file mode 100644 index 0000000..04eef60 --- /dev/null +++ b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/PublicationMarketDocument.java @@ -0,0 +1,77 @@ +package org.openremote.extension.entsoe.agent.protocol; + +import jakarta.xml.bind.annotation.XmlAccessType; +import jakarta.xml.bind.annotation.XmlAccessorType; +import jakarta.xml.bind.annotation.XmlElement; +import jakarta.xml.bind.annotation.XmlRootElement; + +import java.math.BigDecimal; +import java.util.List; + + +@XmlRootElement(name = "Publication_MarketDocument", namespace = PublicationMarketDocument.NS) +@XmlAccessorType(XmlAccessType.FIELD) +public class PublicationMarketDocument { + + public static final String NS = "urn:iec62325.351:tc57wg16:451-3:publicationdocument:7:3"; + + @XmlElement(name = "period.timeInterval", namespace = NS) + private PeriodTimeInterval periodTimeInterval; + + @XmlElement(name = "TimeSeries", namespace = NS) + private List timeSeries; + + @XmlAccessorType(XmlAccessType.FIELD) + public static class PeriodTimeInterval { + @XmlElement(name = "start", namespace = NS) + private String start; + + @XmlElement(name = "end", namespace = NS) + private String end; + + public String getStart() { return start; } + public String getEnd() { return end; } + } + + @XmlAccessorType(XmlAccessType.FIELD) + public static class TimeSeries { + + @XmlElement(name = "Period", namespace = NS) + private Period period; + + public Period getPeriod() { return period; } + } + + @XmlAccessorType(XmlAccessType.FIELD) + public static class Period { + + @XmlElement(name = "timeInterval", namespace = NS) + private PeriodTimeInterval timeInterval; + + @XmlElement(name = "resolution", namespace = NS) + private String resolution; // e.g. PT15M + + @XmlElement(name = "Point", namespace = NS) + private List points; + + public PeriodTimeInterval getTimeInterval() { return timeInterval; } + public String getResolution() { return resolution; } + public List getPoints() { return points; } + } + + @XmlAccessorType(XmlAccessType.FIELD) + public static class Point { + + @XmlElement(name = "position", namespace = NS) + private Integer position; + + @XmlElement(name = "price.amount", namespace = NS) + private BigDecimal priceAmount; + + public Integer getPosition() { return position; } + public BigDecimal getPriceAmount() { return priceAmount; } + } + + public List getTimeSeries() { return timeSeries; } + public PeriodTimeInterval getPeriodTimeInterval() { return periodTimeInterval; } +} diff --git a/entsoe/src/main/resources/META-INF/services/org.openremote.model.AssetModelProvider b/entsoe/src/main/resources/META-INF/services/org.openremote.model.AssetModelProvider new file mode 100644 index 0000000..5162cde --- /dev/null +++ b/entsoe/src/main/resources/META-INF/services/org.openremote.model.AssetModelProvider @@ -0,0 +1 @@ +org.openremote.extension.entsoe.agent.protocol.EntsoeAgentModelProvider diff --git a/entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy b/entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy new file mode 100644 index 0000000..6afe391 --- /dev/null +++ b/entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy @@ -0,0 +1,883 @@ +/* + * Copyright 2026, OpenRemote Inc. + * + * See the CONTRIBUTORS.txt file in the distribution for a + * full listing of individual contributors. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ +package org.openremote.extension.entsoe.agent.protocol + +import jakarta.validation.Validation +import jakarta.ws.rs.client.ClientRequestContext +import jakarta.ws.rs.client.ClientRequestFilter +import jakarta.ws.rs.core.MediaType +import jakarta.ws.rs.core.Response +import org.openremote.manager.agent.AgentService +import org.openremote.manager.asset.AssetStorageService +import org.openremote.manager.datapoint.AssetPredictedDatapointService +import org.openremote.model.asset.agent.ConnectionStatus +import org.openremote.model.asset.impl.ThingAsset +import org.openremote.model.attribute.Attribute +import org.openremote.model.attribute.AttributeRef +import org.openremote.model.attribute.MetaItem +import org.openremote.model.datapoint.ValueDatapoint +import org.openremote.test.ManagerContainerTrait +import spock.lang.Shared +import spock.lang.Specification +import spock.util.concurrent.PollingConditions + +import java.time.Instant +import java.time.ZoneId +import java.time.format.DateTimeFormatter +import java.util.concurrent.TimeUnit + +import static org.openremote.model.Constants.MASTER_REALM +import static org.openremote.model.value.MetaItemType.AGENT_LINK +import static org.openremote.model.value.ValueType.NUMBER + +class EntsoeProtocolTest extends Specification implements ManagerContainerTrait { + private static final String DATASET_START = "2026-02-16T23:00:00.000Z" + private static final String BEFORE_DATASET_START = "2026-02-16T22:00:00.000Z" + + @Shared + Map requestCountByZone = [:].withDefault { 0 } + @Shared + def validator = Validation.buildDefaultValidatorFactory().validator + @Shared + List> requestLog = Collections.synchronizedList(new ArrayList<>()) + + @Shared + def mockServer = new ClientRequestFilter() { + + @Override + void filter(ClientRequestContext requestContext) throws IOException { + // We want the call to take at least 1ms or we get issues with attribute events being ignored as outdated + Thread.sleep(1) + def requestUri = requestContext.uri + + if (requestUri.host == "web-api.tp.entsoe.eu" && requestUri.path == "/api") { + def queryParams = [:] + requestUri.query?.split("&")?.each { pair -> + def parts = pair.split("=", 2) + if (parts.length == 2) { + queryParams[parts[0]] = parts[1] + } + } + def zone = queryParams["in_Domain"] + requestLog.add([ + zone : queryParams["in_Domain"], + periodStart: queryParams["periodStart"], + periodEnd : queryParams["periodEnd"] + ]) + + def content + if (zone == "10YBE----------2") { + content = ''' + + 68f443af488b4a0a9c4442bddd8c59c0 + 1 + A44 + 10X1001A1001A450 + A32 + 10X1001A1001A450 + A33 + 2026-02-17T09:45:56Z + + 2026-02-16T23:00Z + 2026-02-17T23:00Z + + + 1 + A01 + A62 + 10YBE----------2 + 10YBE----------2 + A01 + EUR + MWH + A03 + + + 2026-02-16T23:00Z + 2026-02-17T23:00Z + + PT15M + + 1 + 73.24 + + + 2 + 69.79 + + + 3 + 65.84 + + + 4 + 65.05 + + + + +''' + } else if (zone == "10YNL----------L") { + content = ''' + + bbf443af488b4a0a9c4442bddd8c59c9 + 1 + A44 + 2026-02-17T09:45:56Z + + 2026-02-16T23:00Z + 2026-02-17T23:00Z + + + 1 + A03 + + + 2026-02-16T23:00Z + 2026-02-17T23:00Z + + PT15M + + 1 + 81.11 + + + 2 + 82.22 + + + 3 + 83.33 + + + 4 + 84.44 + + + + +''' + } else if (zone == "10YER----------X") { + requestCountByZone[zone] = requestCountByZone[zone] + 1 + + if (requestCountByZone[zone] == 1) { + content = ''' + + + 2026-02-16T23:00Z + 2026-02-17T23:00Z + + + + + 2026-02-16T23:00Z + 2026-02-17T23:00Z + + PT15M + + 1 + 91.11 + + + 2 + 92.22 + + + 3 + 93.33 + + + 4 + 94.44 + + + + +''' + } else { + requestContext.abortWith(Response.status(500).build()) + return + } + } else if (zone == "10YNDATA-------A") { + content = ''' + + 0985f391-49af-4 + 2026-03-11T06:29:10Z + + 999 + No matching data found for Data item ENERGY_PRICES [12.1.D]. + + +''' + } else if (zone == "10YGAP---------G") { + content = ''' + + + 2026-02-16T23:00Z + 2026-02-17T23:00Z + + + + + 2026-02-16T23:00Z + 2026-02-17T23:00Z + + PT15M + + 1 + 81.11 + + + 2 + 82.22 + + + 4 + 84.44 + + + + +''' + } else { + requestContext.abortWith(Response.serverError().build()) + return + } + + requestContext.abortWith(Response.ok(content, MediaType.APPLICATION_XML_TYPE).build()) + return + } + + requestContext.abortWith(Response.serverError().build()) + } + } + + def "ENTSO-E integration test writes predicted datapoints from publication document"() { + given: "the container environment is started" + requestCountByZone.clear() + def conditions = new PollingConditions(timeout: 10, delay: 0.2) + + EntsoeProtocol.initClient() + + if (!EntsoeProtocol.client.get().configuration.isRegistered(mockServer)) { + EntsoeProtocol.client.get().register(mockServer, Integer.MAX_VALUE) + } + + def container = startContainer(defaultConfig(), defaultServices()) + setPseudoClock(BEFORE_DATASET_START) + def assetStorageService = container.getService(AssetStorageService.class) + def assetPredictedDatapointService = container.getService(AssetPredictedDatapointService.class) + def agentService = container.getService(AgentService.class) + EntsoeAgent agent = null + ThingAsset asset = null + + when: "an ENTSO-E agent is created" + agent = new EntsoeAgent("ENTSO-E Agent") + .setRealm(MASTER_REALM) + .setSecurityToken("test-token") + agent = assetStorageService.merge(agent) + + then: "the protocol instance for the agent should be created and connected" + conditions.eventually { + assert agentService.getProtocolInstance(agent.id) != null + assert ((EntsoeProtocol) agentService.getProtocolInstance(agent.id)) != null + assert agentService.getAgent(agent.id).getAgentStatus().orElse(null) == ConnectionStatus.CONNECTED + } + + when: "an asset attribute is linked to the ENTSO-E agent" + def entsoeLink = new EntsoeAgentLink(agent.id) + entsoeLink.setZone("10YBE----------2") + + asset = new ThingAsset("Energy Price Asset") + .setRealm(MASTER_REALM) + .addOrReplaceAttributes( + new Attribute<>("energyPrice", NUMBER) + .addOrReplaceMeta(new MetaItem<>(AGENT_LINK, entsoeLink)) + ) + asset = assetStorageService.merge(asset) + + def attributeRef = new AttributeRef(asset.id, "energyPrice") + def protocol = (EntsoeProtocol) agentService.getProtocolInstance(agent.id) + + and: "the attribute is linked by protocol" + conditions.eventually { + assert protocol.getLinkedAttributes().containsKey(attributeRef) + } + + and: "a polling update is triggered" + protocol.updateAllLinkedAttributes() + + then: "predicted datapoints are written using period start and resolution" + conditions.eventually { + List datapoints = assetPredictedDatapointService.getDatapoints(attributeRef) + assert datapoints.size() == 4 + + def asc = datapoints.sort { it.timestamp } + def start = Instant.parse(DATASET_START).toEpochMilli() + def step = 15 * 60 * 1000L + + assert asc[0].timestamp == start + assert asc[1].timestamp == start + step + assert asc[2].timestamp == start + (2 * step) + assert asc[3].timestamp == start + (3 * step) + + assert (asc[0].value as BigDecimal).compareTo(73.24G) == 0 + assert (asc[1].value as BigDecimal).compareTo(69.79G) == 0 + assert (asc[2].value as BigDecimal).compareTo(65.84G) == 0 + assert (asc[3].value as BigDecimal).compareTo(65.05G) == 0 + } + + cleanup: "remove created assets and mock client" + if (asset?.id) { + assetStorageService.delete([asset.id]) + } + if (agent?.id) { + assetStorageService.delete([agent.id]) + } + if (EntsoeProtocol.client.get() != null) { + EntsoeProtocol.client.set(null) + } + } + + def "ENTSO-E integration test filters out points in the past when clock is mid-period"() { + given: "the container environment is started with clock in the middle of the dataset period" + requestCountByZone.clear() + def conditions = new PollingConditions(timeout: 10, delay: 0.2) + + EntsoeProtocol.initClient() + + if (!EntsoeProtocol.client.get().configuration.isRegistered(mockServer)) { + EntsoeProtocol.client.get().register(mockServer, Integer.MAX_VALUE) + } + + def container = startContainer(defaultConfig(), defaultServices()) + setPseudoClock("2026-02-16T23:20:00.000Z") + def assetStorageService = container.getService(AssetStorageService.class) + def assetPredictedDatapointService = container.getService(AssetPredictedDatapointService.class) + def agentService = container.getService(AgentService.class) + EntsoeAgent agent = null + ThingAsset asset = null + + when: "an ENTSO-E agent and linked attribute are created" + agent = new EntsoeAgent("ENTSO-E Agent") + .setRealm(MASTER_REALM) + .setSecurityToken("test-token") + agent = assetStorageService.merge(agent) + + def entsoeLink = new EntsoeAgentLink(agent.id) + entsoeLink.setZone("10YBE----------2") + + asset = new ThingAsset("Energy Price Asset") + .setRealm(MASTER_REALM) + .addOrReplaceAttributes( + new Attribute<>("energyPrice", NUMBER) + .addOrReplaceMeta(new MetaItem<>(AGENT_LINK, entsoeLink)) + ) + asset = assetStorageService.merge(asset) + + def attributeRef = new AttributeRef(asset.id, "energyPrice") + def protocol = (EntsoeProtocol) agentService.getProtocolInstance(agent.id) + + then: "the protocol is connected and attribute linked" + conditions.eventually { + assert protocol != null + assert agentService.getAgent(agent.id).getAgentStatus().orElse(null) == ConnectionStatus.CONNECTED + assert protocol.getLinkedAttributes().containsKey(attributeRef) + } + + when: "a polling update is triggered" + protocol.updateAllLinkedAttributes() + + then: "only datapoints after the cutoff time are stored" + conditions.eventually { + List datapoints = assetPredictedDatapointService.getDatapoints(attributeRef).sort { it.timestamp } + assert datapoints.size() == 2 + + def start = Instant.parse(DATASET_START).toEpochMilli() + def step = 15 * 60 * 1000L + + assert datapoints[0].timestamp == start + (2 * step) + assert datapoints[1].timestamp == start + (3 * step) + assert (datapoints[0].value as BigDecimal).compareTo(65.84G) == 0 + assert (datapoints[1].value as BigDecimal).compareTo(65.05G) == 0 + } + + cleanup: "remove created assets and mock client" + if (asset?.id) { + assetStorageService.delete([asset.id]) + } + if (agent?.id) { + assetStorageService.delete([agent.id]) + } + if (EntsoeProtocol.client.get() != null) { + EntsoeProtocol.client.set(null) + } + } + + def "ENTSO-E integration test writes predicted datapoints for 2 linked attributes with different zones"() { + given: "the container environment is started" + requestCountByZone.clear() + def conditions = new PollingConditions(timeout: 10, delay: 0.2) + + EntsoeProtocol.initClient() + + if (!EntsoeProtocol.client.get().configuration.isRegistered(mockServer)) { + EntsoeProtocol.client.get().register(mockServer, Integer.MAX_VALUE) + } + + def container = startContainer(defaultConfig(), defaultServices()) + setPseudoClock(BEFORE_DATASET_START) + def assetStorageService = container.getService(AssetStorageService.class) + def assetPredictedDatapointService = container.getService(AssetPredictedDatapointService.class) + def agentService = container.getService(AgentService.class) + EntsoeAgent agent = null + ThingAsset asset = null + + when: "an ENTSO-E agent is created" + agent = new EntsoeAgent("ENTSO-E Agent") + .setRealm(MASTER_REALM) + .setSecurityToken("test-token") + agent = assetStorageService.merge(agent) + + then: "the protocol instance for the agent should be created and connected" + conditions.eventually { + assert agentService.getProtocolInstance(agent.id) != null + assert ((EntsoeProtocol) agentService.getProtocolInstance(agent.id)) != null + assert agentService.getAgent(agent.id).getAgentStatus().orElse(null) == ConnectionStatus.CONNECTED + } + + when: "2 attributes are linked to the same agent with different zones" + def beLink = new EntsoeAgentLink(agent.id) + beLink.setZone("10YBE----------2") + def nlLink = new EntsoeAgentLink(agent.id) + nlLink.setZone("10YNL----------L") + + asset = new ThingAsset("Multi Zone Energy Price Asset") + .setRealm(MASTER_REALM) + .addOrReplaceAttributes( + new Attribute<>("energyPriceBe", NUMBER) + .addOrReplaceMeta(new MetaItem<>(AGENT_LINK, beLink)), + new Attribute<>("energyPriceNl", NUMBER) + .addOrReplaceMeta(new MetaItem<>(AGENT_LINK, nlLink)) + ) + asset = assetStorageService.merge(asset) + + def beRef = new AttributeRef(asset.id, "energyPriceBe") + def nlRef = new AttributeRef(asset.id, "energyPriceNl") + def protocol = (EntsoeProtocol) agentService.getProtocolInstance(agent.id) + + and: "both attributes are linked by protocol" + conditions.eventually { + assert protocol.getLinkedAttributes().containsKey(beRef) + assert protocol.getLinkedAttributes().containsKey(nlRef) + } + + and: "a polling update is triggered" + protocol.updateAllLinkedAttributes() + + then: "each attribute receives predicted datapoints for its configured zone" + conditions.eventually { + List beDatapoints = assetPredictedDatapointService.getDatapoints(beRef).sort { it.timestamp } + List nlDatapoints = assetPredictedDatapointService.getDatapoints(nlRef).sort { it.timestamp } + + assert beDatapoints.size() == 4 + assert nlDatapoints.size() == 4 + + assert (beDatapoints[0].value as BigDecimal).compareTo(73.24G) == 0 + assert (beDatapoints[1].value as BigDecimal).compareTo(69.79G) == 0 + assert (beDatapoints[2].value as BigDecimal).compareTo(65.84G) == 0 + assert (beDatapoints[3].value as BigDecimal).compareTo(65.05G) == 0 + + assert (nlDatapoints[0].value as BigDecimal).compareTo(81.11G) == 0 + assert (nlDatapoints[1].value as BigDecimal).compareTo(82.22G) == 0 + assert (nlDatapoints[2].value as BigDecimal).compareTo(83.33G) == 0 + assert (nlDatapoints[3].value as BigDecimal).compareTo(84.44G) == 0 + } + + cleanup: "remove created assets and mock client" + if (asset?.id) { + assetStorageService.delete([asset.id]) + } + if (agent?.id) { + assetStorageService.delete([agent.id]) + } + if (EntsoeProtocol.client.get() != null) { + EntsoeProtocol.client.set(null) + } + } + + def "ENTSO-E integration test keeps existing predicted datapoints when subsequent poll fetch fails"() { + given: "the container environment is started" + requestCountByZone.clear() + def conditions = new PollingConditions(timeout: 10, delay: 0.2) + + EntsoeProtocol.initClient() + + if (!EntsoeProtocol.client.get().configuration.isRegistered(mockServer)) { + EntsoeProtocol.client.get().register(mockServer, Integer.MAX_VALUE) + } + + def container = startContainer(defaultConfig(), defaultServices()) + setPseudoClock(BEFORE_DATASET_START) + def assetStorageService = container.getService(AssetStorageService.class) + def assetPredictedDatapointService = container.getService(AssetPredictedDatapointService.class) + def agentService = container.getService(AgentService.class) + EntsoeAgent agent = null + ThingAsset asset = null + + when: "an ENTSO-E agent is created" + agent = new EntsoeAgent("ENTSO-E Agent") + .setRealm(MASTER_REALM) + .setSecurityToken("test-token") + agent = assetStorageService.merge(agent) + + then: "the protocol instance for the agent should be created and connected" + conditions.eventually { + assert agentService.getProtocolInstance(agent.id) != null + assert ((EntsoeProtocol) agentService.getProtocolInstance(agent.id)) != null + assert agentService.getAgent(agent.id).getAgentStatus().orElse(null) == ConnectionStatus.CONNECTED + } + + when: "an attribute is linked to a zone that fails after first successful fetch" + def errLink = new EntsoeAgentLink(agent.id) + errLink.setZone("10YER----------X") + + asset = new ThingAsset("Error On Second Poll Asset") + .setRealm(MASTER_REALM) + .addOrReplaceAttributes( + new Attribute<>("energyPrice", NUMBER) + .addOrReplaceMeta(new MetaItem<>(AGENT_LINK, errLink)) + ) + asset = assetStorageService.merge(asset) + + def attributeRef = new AttributeRef(asset.id, "energyPrice") + def protocol = (EntsoeProtocol) agentService.getProtocolInstance(agent.id) + + and: "the attribute is linked by protocol" + conditions.eventually { + assert protocol.getLinkedAttributes().containsKey(attributeRef) + } + + and: "first poll succeeds" + protocol.updateAllLinkedAttributes() + + then: "predicted datapoints are written" + def firstSnapshot + conditions.eventually { + List datapoints = assetPredictedDatapointService.getDatapoints(attributeRef).sort { it.timestamp } + assert datapoints.size() == 4 + assert (datapoints[0].value as BigDecimal).compareTo(91.11G) == 0 + assert (datapoints[1].value as BigDecimal).compareTo(92.22G) == 0 + assert (datapoints[2].value as BigDecimal).compareTo(93.33G) == 0 + assert (datapoints[3].value as BigDecimal).compareTo(94.44G) == 0 + firstSnapshot = datapoints.collect { [it.timestamp, (it.value as BigDecimal)] } + } + + when: "next poll cycle fetch fails" + protocol.updateAllLinkedAttributes() + + then: "existing predicted datapoints remain available" + conditions.eventually { + List datapoints = assetPredictedDatapointService.getDatapoints(attributeRef).sort { it.timestamp } + assert datapoints.size() == 4 + assert firstSnapshot != null + assert datapoints.collect { [it.timestamp, (it.value as BigDecimal)] } == firstSnapshot + } + + cleanup: "remove created assets and mock client" + if (asset?.id) { + assetStorageService.delete([asset.id]) + } + if (agent?.id) { + assetStorageService.delete([agent.id]) + } + if (EntsoeProtocol.client.get() != null) { + EntsoeProtocol.client.set(null) + } + } + + def "ENTSO-E integration test handles no-data acknowledgement response cleanly"() { + given: "the container environment is started" + requestCountByZone.clear() + def conditions = new PollingConditions(timeout: 10, delay: 0.2) + + EntsoeProtocol.initClient() + + if (!EntsoeProtocol.client.get().configuration.isRegistered(mockServer)) { + EntsoeProtocol.client.get().register(mockServer, Integer.MAX_VALUE) + } + + def container = startContainer(defaultConfig(), defaultServices()) + setPseudoClock(BEFORE_DATASET_START) + def assetStorageService = container.getService(AssetStorageService.class) + def assetPredictedDatapointService = container.getService(AssetPredictedDatapointService.class) + def agentService = container.getService(AgentService.class) + EntsoeAgent agent = null + ThingAsset asset = null + + when: "an ENTSO-E agent is created" + agent = new EntsoeAgent("ENTSO-E Agent") + .setRealm(MASTER_REALM) + .setSecurityToken("test-token") + agent = assetStorageService.merge(agent) + + then: "the protocol instance for the agent should be created and connected" + conditions.eventually { + assert agentService.getProtocolInstance(agent.id) != null + assert ((EntsoeProtocol) agentService.getProtocolInstance(agent.id)) != null + assert agentService.getAgent(agent.id).getAgentStatus().orElse(null) == ConnectionStatus.CONNECTED + } + + when: "an attribute is linked to a zone that returns no-data acknowledgement" + def noDataLink = new EntsoeAgentLink(agent.id) + noDataLink.setZone("10YNDATA-------A") + + asset = new ThingAsset("No Data Zone Asset") + .setRealm(MASTER_REALM) + .addOrReplaceAttributes( + new Attribute<>("energyPrice", NUMBER) + .addOrReplaceMeta(new MetaItem<>(AGENT_LINK, noDataLink)) + ) + asset = assetStorageService.merge(asset) + + def attributeRef = new AttributeRef(asset.id, "energyPrice") + def protocol = (EntsoeProtocol) agentService.getProtocolInstance(agent.id) + + and: "the attribute is linked by protocol" + conditions.eventually { + assert protocol.getLinkedAttributes().containsKey(attributeRef) + } + + and: "a polling update is triggered" + protocol.updateAllLinkedAttributes() + + then: "no predicted datapoints are written and no exception escapes" + conditions.eventually { + List datapoints = assetPredictedDatapointService.getDatapoints(attributeRef) + assert datapoints.isEmpty() + } + + cleanup: "remove created assets and mock client" + if (asset?.id) { + assetStorageService.delete([asset.id]) + } + if (agent?.id) { + assetStorageService.delete([agent.id]) + } + if (EntsoeProtocol.client.get() != null) { + EntsoeProtocol.client.set(null) + } + } + + def "ENTSO-E integration test keeps position timing when intermediate point is missing"() { + given: "the container environment is started" + requestCountByZone.clear() + def conditions = new PollingConditions(timeout: 10, delay: 0.2) + + EntsoeProtocol.initClient() + + if (!EntsoeProtocol.client.get().configuration.isRegistered(mockServer)) { + EntsoeProtocol.client.get().register(mockServer, Integer.MAX_VALUE) + } + + def container = startContainer(defaultConfig(), defaultServices()) + setPseudoClock(BEFORE_DATASET_START) + def assetStorageService = container.getService(AssetStorageService.class) + def assetPredictedDatapointService = container.getService(AssetPredictedDatapointService.class) + def agentService = container.getService(AgentService.class) + EntsoeAgent agent = null + ThingAsset asset = null + + when: "an ENTSO-E agent and linked attribute are created for a zone with a missing point position" + agent = new EntsoeAgent("ENTSO-E Agent") + .setRealm(MASTER_REALM) + .setSecurityToken("test-token") + agent = assetStorageService.merge(agent) + + def gapLink = new EntsoeAgentLink(agent.id) + gapLink.setZone("10YGAP---------G") + + asset = new ThingAsset("Gap Position Asset") + .setRealm(MASTER_REALM) + .addOrReplaceAttributes( + new Attribute<>("energyPrice", NUMBER) + .addOrReplaceMeta(new MetaItem<>(AGENT_LINK, gapLink)) + ) + asset = assetStorageService.merge(asset) + + def attributeRef = new AttributeRef(asset.id, "energyPrice") + def protocol = (EntsoeProtocol) agentService.getProtocolInstance(agent.id) + + then: "the protocol is connected and attribute linked" + conditions.eventually { + assert protocol != null + assert agentService.getAgent(agent.id).getAgentStatus().orElse(null) == ConnectionStatus.CONNECTED + assert protocol.getLinkedAttributes().containsKey(attributeRef) + } + + when: "a polling update is triggered" + protocol.updateAllLinkedAttributes() + + then: "only provided points are stored and their timestamps follow position offsets" + conditions.eventually { + List datapoints = assetPredictedDatapointService.getDatapoints(attributeRef).sort { it.timestamp } + assert datapoints.size() == 3 + + def start = Instant.parse(DATASET_START).toEpochMilli() + def step = 15 * 60 * 1000L + + assert datapoints[0].timestamp == start + assert datapoints[1].timestamp == start + step + assert datapoints[2].timestamp == start + (3 * step) + assert datapoints[2].timestamp - datapoints[1].timestamp == 2 * step + + assert (datapoints[0].value as BigDecimal).compareTo(81.11G) == 0 + assert (datapoints[1].value as BigDecimal).compareTo(82.22G) == 0 + assert (datapoints[2].value as BigDecimal).compareTo(84.44G) == 0 + } + + cleanup: "remove created assets and mock client" + if (asset?.id) { + assetStorageService.delete([asset.id]) + } + if (agent?.id) { + assetStorageService.delete([agent.id]) + } + if (EntsoeProtocol.client.get() != null) { + EntsoeProtocol.client.set(null) + } + } + + def "ENTSO-E agent link validates zone against EIC regex pattern"() { + given: "an ENTSO-E agent link" + def link = new EntsoeAgentLink("agent-id") + + expect: "zone validation follows the EIC regex" + link.setZone(zoneId) + validator.validate(link).isEmpty() == valid + + where: + zoneId || valid + "10YBE----------2" || true + "10YNL----------L" || true + "10YGAP---------G" || true + "1YBE----------2" || false + "10yBE----------2" || false + "10YBE----------" || false + "10YBE----------22" || false + "10YBE_____-----2" || false + "10YNDATA-------A" || true + } + + def "ENTSO-E integration test updates requested period range when clock advances by one day"() { + given: "the container environment is started" + requestCountByZone.clear() + requestLog.clear() + def conditions = new PollingConditions(timeout: 10, delay: 0.2) + def periodFormatter = DateTimeFormatter.ofPattern("yyyyMMddHHmm").withZone(ZoneId.of("UTC")) + + EntsoeProtocol.initClient() + + if (!EntsoeProtocol.client.get().configuration.isRegistered(mockServer)) { + EntsoeProtocol.client.get().register(mockServer, Integer.MAX_VALUE) + } + + def container = startContainer(defaultConfig(), defaultServices()) + def assetStorageService = container.getService(AssetStorageService.class) + def agentService = container.getService(AgentService.class) + EntsoeAgent agent = null + ThingAsset asset = null + + when: "an ENTSO-E agent is created" + agent = new EntsoeAgent("ENTSO-E Agent") + .setRealm(MASTER_REALM) + .setSecurityToken("test-token") + agent = assetStorageService.merge(agent) + + then: "the protocol instance for the agent should be created and connected" + conditions.eventually { + assert agentService.getProtocolInstance(agent.id) != null + assert ((EntsoeProtocol) agentService.getProtocolInstance(agent.id)) != null + assert agentService.getAgent(agent.id).getAgentStatus().orElse(null) == ConnectionStatus.CONNECTED + } + + when: "an asset attribute is linked to the ENTSO-E agent" + def link = new EntsoeAgentLink(agent.id) + link.setZone("10YBE----------2") + + asset = new ThingAsset("Time Range Asset") + .setRealm(MASTER_REALM) + .addOrReplaceAttributes( + new Attribute<>("energyPrice", NUMBER) + .addOrReplaceMeta(new MetaItem<>(AGENT_LINK, link)) + ) + asset = assetStorageService.merge(asset) + + def attributeRef = new AttributeRef(asset.id, "energyPrice") + def protocol = (EntsoeProtocol) agentService.getProtocolInstance(agent.id) + + and: "the attribute is linked by protocol" + conditions.eventually { + assert protocol.getLinkedAttributes().containsKey(attributeRef) + } + + and: "an update is triggered at the fixed time" + stopPseudoClock() + setPseudoClock("2026-02-10T10:15:00.000Z") + def fixedNow = Instant.parse("2026-02-10T10:15:00.000Z") + requestLog.clear() + protocol.updateAllLinkedAttributes() + + then: "request periodStart/periodEnd use the fixed clock time" + conditions.eventually { + assert requestLog.any { + it.zone == "10YBE----------2" && + it.periodStart == periodFormatter.format(fixedNow) && + it.periodEnd == periodFormatter.format(fixedNow.plus(1, java.time.temporal.ChronoUnit.DAYS)) + } + } + + when: "clock advances by one day and another update is triggered" + advancePseudoClock(1, TimeUnit.DAYS, container) + def nextNow = fixedNow.plus(1, java.time.temporal.ChronoUnit.DAYS) + requestLog.clear() + protocol.updateAllLinkedAttributes() + + then: "request periodStart/periodEnd are shifted by one day" + conditions.eventually { + assert requestLog.any { + it.zone == "10YBE----------2" && + it.periodStart == periodFormatter.format(nextNow) && + it.periodEnd == periodFormatter.format(nextNow.plus(1, java.time.temporal.ChronoUnit.DAYS)) + } + } + + cleanup: "remove created assets and mock client" + if (asset?.id) { + assetStorageService.delete([asset.id]) + } + if (agent?.id) { + assetStorageService.delete([agent.id]) + } + if (EntsoeProtocol.client.get() != null) { + EntsoeProtocol.client.set(null) + } + } +} From 63478fcf182fe11f828533a8c7e3488a3e60697c Mon Sep 17 00:00:00 2001 From: Eric Bariaux <375613+ebariaux@users.noreply.github.com> Date: Mon, 23 Mar 2026 13:05:11 +0100 Subject: [PATCH 03/13] Support multiple entries in a single --- .../entsoe/agent/protocol/EntsoeProtocol.java | 61 +++++---- .../protocol/PublicationMarketDocument.java | 4 +- .../agent/protocol/EntsoeProtocolTest.groovy | 125 ++++++++++++++++++ 3 files changed, 160 insertions(+), 30 deletions(-) diff --git a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java index aac6b79..ab49d60 100644 --- a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java +++ b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java @@ -324,39 +324,44 @@ protected List> buildPredictedDatapoints(PublicationMarketDocu } for (PublicationMarketDocument.TimeSeries timeSeries : document.getTimeSeries()) { - PublicationMarketDocument.Period period = timeSeries.getPeriod(); - if (period == null || period.getPoints() == null || period.getPoints().isEmpty()) { + if (timeSeries.getPeriods() == null || timeSeries.getPeriods().isEmpty()) { continue; } - PublicationMarketDocument.PeriodTimeInterval timeInterval = period.getTimeInterval() != null - ? period.getTimeInterval() - : document.getPeriodTimeInterval(); - if (timeInterval == null || timeInterval.getStart() == null || period.getResolution() == null) { - continue; - } + for (PublicationMarketDocument.Period period : timeSeries.getPeriods()) { + if (period == null || period.getPoints() == null || period.getPoints().isEmpty()) { + continue; + } - final Instant start; - final Duration resolution; - try { - start = parseEntsoeInstant(timeInterval.getStart()); - resolution = Duration.parse(period.getResolution()); - } catch (Exception e) { - LOG.log(Level.WARNING, e, () -> "Could not parse ENTSO-E timeseries time data"); - continue; - } + PublicationMarketDocument.PeriodTimeInterval timeInterval = period.getTimeInterval() != null + ? period.getTimeInterval() + : document.getPeriodTimeInterval(); + if (timeInterval == null || timeInterval.getStart() == null || period.getResolution() == null) { + continue; + } + + final Instant start; + final Duration resolution; + try { + start = parseEntsoeInstant(timeInterval.getStart()); + resolution = Duration.parse(period.getResolution()); + } catch (Exception e) { + LOG.log(Level.WARNING, e, () -> "Could not parse ENTSO-E timeseries time data"); + continue; + } - period.getPoints().stream() - .filter(point -> point.getPosition() != null && point.getPosition() > 0 && point.getPriceAmount() != null) - .sorted(Comparator.comparingInt(PublicationMarketDocument.Point::getPosition)) - .forEach(point -> { - long timestamp = start - .plus(resolution.multipliedBy(point.getPosition() - 1L)) - .toEpochMilli(); - if (timestamp >= nowMillis) { - values.add(new ValueDatapoint<>(timestamp, point.getPriceAmount())); - } - }); + period.getPoints().stream() + .filter(point -> point.getPosition() != null && point.getPosition() > 0 && point.getPriceAmount() != null) + .sorted(Comparator.comparingInt(PublicationMarketDocument.Point::getPosition)) + .forEach(point -> { + long timestamp = start + .plus(resolution.multipliedBy(point.getPosition() - 1L)) + .toEpochMilli(); + if (timestamp >= nowMillis) { + values.add(new ValueDatapoint<>(timestamp, point.getPriceAmount())); + } + }); + } } values.sort(Comparator.comparingLong(ValueDatapoint::getTimestamp)); diff --git a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/PublicationMarketDocument.java b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/PublicationMarketDocument.java index 04eef60..6cdeaab 100644 --- a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/PublicationMarketDocument.java +++ b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/PublicationMarketDocument.java @@ -37,9 +37,9 @@ public static class PeriodTimeInterval { public static class TimeSeries { @XmlElement(name = "Period", namespace = NS) - private Period period; + private List periods; - public Period getPeriod() { return period; } + public List getPeriods() { return periods; } } @XmlAccessorType(XmlAccessType.FIELD) diff --git a/entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy b/entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy index 6afe391..5e3b7f5 100644 --- a/entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy +++ b/entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy @@ -255,6 +255,49 @@ class EntsoeProtocolTest extends Specification implements ManagerContainerTrait +''' + } else if (zone == "10YMULTI-------A") { + content = ''' + + + 2026-02-16T23:00Z + 2026-02-17T01:00Z + + + 1 + A03 + + + 2026-02-16T23:00Z + 2026-02-17T00:00Z + + PT15M + + 1 + 51.11 + + + 2 + 52.22 + + + + + 2026-02-17T00:00Z + 2026-02-17T01:00Z + + PT15M + + 1 + 53.33 + + + 2 + 54.44 + + + + ''' } else { requestContext.abortWith(Response.serverError().build()) @@ -765,6 +808,87 @@ class EntsoeProtocolTest extends Specification implements ManagerContainerTrait } } + def "ENTSO-E integration test supports multiple periods in a single timeseries"() { + given: "the container environment is started" + requestCountByZone.clear() + def conditions = new PollingConditions(timeout: 10, delay: 0.2) + + EntsoeProtocol.initClient() + + if (!EntsoeProtocol.client.get().configuration.isRegistered(mockServer)) { + EntsoeProtocol.client.get().register(mockServer, Integer.MAX_VALUE) + } + + def container = startContainer(defaultConfig(), defaultServices()) + setPseudoClock(BEFORE_DATASET_START) + def assetStorageService = container.getService(AssetStorageService.class) + def assetPredictedDatapointService = container.getService(AssetPredictedDatapointService.class) + def agentService = container.getService(AgentService.class) + EntsoeAgent agent = null + ThingAsset asset = null + + when: "an ENTSO-E agent and linked attribute are created for a zone with multiple periods in one timeseries" + agent = new EntsoeAgent("ENTSO-E Agent") + .setRealm(MASTER_REALM) + .setSecurityToken("test-token") + agent = assetStorageService.merge(agent) + + def multiPeriodLink = new EntsoeAgentLink(agent.id) + multiPeriodLink.setZone("10YMULTI-------A") + + asset = new ThingAsset("Multi Period Asset") + .setRealm(MASTER_REALM) + .addOrReplaceAttributes( + new Attribute<>("energyPrice", NUMBER) + .addOrReplaceMeta(new MetaItem<>(AGENT_LINK, multiPeriodLink)) + ) + asset = assetStorageService.merge(asset) + + def attributeRef = new AttributeRef(asset.id, "energyPrice") + def protocol = (EntsoeProtocol) agentService.getProtocolInstance(agent.id) + + then: "the protocol is connected and attribute linked" + conditions.eventually { + assert protocol != null + assert agentService.getAgent(agent.id).getAgentStatus().orElse(null) == ConnectionStatus.CONNECTED + assert protocol.getLinkedAttributes().containsKey(attributeRef) + } + + when: "a polling update is triggered" + protocol.updateAllLinkedAttributes() + + then: "datapoints are produced from all periods in order" + conditions.eventually { + List datapoints = assetPredictedDatapointService.getDatapoints(attributeRef).sort { it.timestamp } + assert datapoints.size() == 4 + + def firstPeriodStart = Instant.parse(DATASET_START).toEpochMilli() + def secondPeriodStart = Instant.parse("2026-02-17T00:00:00.000Z").toEpochMilli() + def step = 15 * 60 * 1000L + + assert datapoints[0].timestamp == firstPeriodStart + assert datapoints[1].timestamp == firstPeriodStart + step + assert datapoints[2].timestamp == secondPeriodStart + assert datapoints[3].timestamp == secondPeriodStart + step + + assert (datapoints[0].value as BigDecimal).compareTo(51.11G) == 0 + assert (datapoints[1].value as BigDecimal).compareTo(52.22G) == 0 + assert (datapoints[2].value as BigDecimal).compareTo(53.33G) == 0 + assert (datapoints[3].value as BigDecimal).compareTo(54.44G) == 0 + } + + cleanup: "remove created assets and mock client" + if (asset?.id) { + assetStorageService.delete([asset.id]) + } + if (agent?.id) { + assetStorageService.delete([agent.id]) + } + if (EntsoeProtocol.client.get() != null) { + EntsoeProtocol.client.set(null) + } + } + def "ENTSO-E agent link validates zone against EIC regex pattern"() { given: "an ENTSO-E agent link" def link = new EntsoeAgentLink("agent-id") @@ -784,6 +908,7 @@ class EntsoeProtocolTest extends Specification implements ManagerContainerTrait "10YBE----------22" || false "10YBE_____-----2" || false "10YNDATA-------A" || true + "10YMULTI-------A" || true } def "ENTSO-E integration test updates requested period range when clock advances by one day"() { From dfbc5822ccb6c456a545ea360f4763418c4b254b Mon Sep 17 00:00:00 2001 From: Eric Bariaux <375613+ebariaux@users.noreply.github.com> Date: Mon, 23 Mar 2026 13:07:43 +0100 Subject: [PATCH 04/13] Add licence header --- .../entsoe/agent/protocol/EntsoeAgent.java | 19 +++++++++++++++++++ .../agent/protocol/EntsoeAgentLink.java | 19 +++++++++++++++++++ .../protocol/EntsoeAgentModelProvider.java | 19 +++++++++++++++++++ .../entsoe/agent/protocol/EntsoeProtocol.java | 19 +++++++++++++++++++ .../protocol/PublicationMarketDocument.java | 19 +++++++++++++++++++ 5 files changed, 95 insertions(+) diff --git a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeAgent.java b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeAgent.java index 7312e45..b763253 100644 --- a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeAgent.java +++ b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeAgent.java @@ -1,3 +1,22 @@ +/* + * Copyright 2026, OpenRemote Inc. + * + * See the CONTRIBUTORS.txt file in the distribution for a + * full listing of individual contributors. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ package org.openremote.extension.entsoe.agent.protocol; import jakarta.persistence.Entity; diff --git a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeAgentLink.java b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeAgentLink.java index 624e3b5..39ef128 100644 --- a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeAgentLink.java +++ b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeAgentLink.java @@ -1,3 +1,22 @@ +/* + * Copyright 2026, OpenRemote Inc. + * + * See the CONTRIBUTORS.txt file in the distribution for a + * full listing of individual contributors. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ package org.openremote.extension.entsoe.agent.protocol; import com.fasterxml.jackson.annotation.JsonPropertyDescription; diff --git a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeAgentModelProvider.java b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeAgentModelProvider.java index 278e36b..a6d3c7d 100644 --- a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeAgentModelProvider.java +++ b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeAgentModelProvider.java @@ -1,3 +1,22 @@ +/* + * Copyright 2026, OpenRemote Inc. + * + * See the CONTRIBUTORS.txt file in the distribution for a + * full listing of individual contributors. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ package org.openremote.extension.entsoe.agent.protocol; import org.openremote.model.AssetModelProvider; diff --git a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java index ab49d60..3b3e39c 100644 --- a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java +++ b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java @@ -1,3 +1,22 @@ +/* + * Copyright 2026, OpenRemote Inc. + * + * See the CONTRIBUTORS.txt file in the distribution for a + * full listing of individual contributors. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ package org.openremote.extension.entsoe.agent.protocol; import jakarta.ws.rs.core.Response; diff --git a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/PublicationMarketDocument.java b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/PublicationMarketDocument.java index 6cdeaab..e555427 100644 --- a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/PublicationMarketDocument.java +++ b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/PublicationMarketDocument.java @@ -1,3 +1,22 @@ +/* + * Copyright 2026, OpenRemote Inc. + * + * See the CONTRIBUTORS.txt file in the distribution for a + * full listing of individual contributors. + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU Affero General Public License as + * published by the Free Software Foundation, either version 3 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Affero General Public License for more details. + * + * You should have received a copy of the GNU Affero General Public License + * along with this program. If not, see . + */ package org.openremote.extension.entsoe.agent.protocol; import jakarta.xml.bind.annotation.XmlAccessType; From bd1a943a391af2a7627c9243cf23b83272a32dcd Mon Sep 17 00:00:00 2001 From: Eric Bariaux <375613+ebariaux@users.noreply.github.com> Date: Mon, 23 Mar 2026 13:14:44 +0100 Subject: [PATCH 05/13] Improve fetching so that if multiple attributes sahre the same zone fetching is only done once. --- .../entsoe/agent/protocol/EntsoeProtocol.java | 42 ++++++--- .../agent/protocol/EntsoeProtocolTest.groovy | 89 +++++++++++++++++++ 2 files changed, 120 insertions(+), 11 deletions(-) diff --git a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java index 3b3e39c..d5ce906 100644 --- a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java +++ b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java @@ -47,7 +47,9 @@ import java.time.temporal.ChronoUnit; import java.util.ArrayList; import java.util.Comparator; +import java.util.LinkedHashMap; import java.util.List; +import java.util.Map; import java.util.concurrent.ScheduledFuture; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicReference; @@ -168,28 +170,46 @@ protected void updateAllLinkedAttributes() { return; } - getLinkedAttributes().forEach(this::updatePricingInformation); + Map>> attributesByZone = collectLinkedAttributesByZone(); + + attributesByZone.forEach((zone, linkedAttributesForZone) -> { + PublicationMarketDocument document = fetchPricingInformation(buildApiUrl(zone)); + applyPricingInformation(zone, document, linkedAttributesForZone); + }); } - protected void updatePricingInformation(AttributeRef attributeRefs, Attribute attribute) { - LOG.fine("Updating pricing information data for attribute " + attribute.getName()); + protected Map>> collectLinkedAttributesByZone() { + Map>> attributesByZone = new LinkedHashMap<>(); + + getLinkedAttributes().forEach((attributeRef, attribute) -> { + EntsoeAgentLink agentLink = agent.getAgentLink(attribute); + attributesByZone.computeIfAbsent(agentLink.getZone(), ignored -> new ArrayList<>()) + .add(Map.entry(attributeRef, attribute)); + }); - EntsoeAgentLink agentLink = agent.getAgentLink(attribute); + return attributesByZone; + } - PublicationMarketDocument doc = fetchPricingInformation(buildApiUrl(agentLink.getZone())); - if (doc == null) { - LOG.warning(() -> "No ENTSO-E publication document returned for attribute: " + attributeRefs); + protected void applyPricingInformation(String zone, PublicationMarketDocument document, List> linkedAttributesForZone) { + if (document == null) { + linkedAttributesForZone.forEach(entry -> + LOG.warning(() -> "No ENTSO-E publication document returned for attribute: " + entry.getKey() + " in zone: " + zone)); return; } - List> predictedDatapoints = buildPredictedDatapoints(doc); + List> predictedDatapoints = buildPredictedDatapoints(document); if (predictedDatapoints.isEmpty()) { - LOG.warning(() -> "No datapoints built from ENTSO-E publication document for attribute: " + attributeRefs); + linkedAttributesForZone.forEach(entry -> + LOG.warning(() -> "No datapoints built from ENTSO-E publication document for attribute: " + entry.getKey() + " in zone: " + zone)); return; } - predictedDatapointService.updateValues(attributeRefs.getId(), attributeRefs.getName(), predictedDatapoints); - + linkedAttributesForZone.forEach(entry -> { + AttributeRef attributeRef = entry.getKey(); + Attribute attribute = entry.getValue(); + LOG.fine("Updating pricing information data for attribute " + attribute.getName()); + predictedDatapointService.updateValues(attributeRef.getId(), attributeRef.getName(), predictedDatapoints); + }); } protected String buildApiUrl(String zone) { diff --git a/entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy b/entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy index 5e3b7f5..30ce85a 100644 --- a/entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy +++ b/entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy @@ -566,6 +566,95 @@ class EntsoeProtocolTest extends Specification implements ManagerContainerTrait } } + def "ENTSO-E integration test fetches a shared zone only once per polling cycle"() { + given: "the container environment is started" + requestCountByZone.clear() + requestLog.clear() + def conditions = new PollingConditions(timeout: 10, delay: 0.2) + + EntsoeProtocol.initClient() + + if (!EntsoeProtocol.client.get().configuration.isRegistered(mockServer)) { + EntsoeProtocol.client.get().register(mockServer, Integer.MAX_VALUE) + } + + def container = startContainer(defaultConfig(), defaultServices()) + setPseudoClock(BEFORE_DATASET_START) + def assetStorageService = container.getService(AssetStorageService.class) + def assetPredictedDatapointService = container.getService(AssetPredictedDatapointService.class) + def agentService = container.getService(AgentService.class) + EntsoeAgent agent = null + ThingAsset asset = null + + when: "an ENTSO-E agent is created" + agent = new EntsoeAgent("ENTSO-E Agent") + .setRealm(MASTER_REALM) + .setSecurityToken("test-token") + agent = assetStorageService.merge(agent) + + then: "the protocol instance for the agent should be created and connected" + conditions.eventually { + assert agentService.getProtocolInstance(agent.id) != null + assert ((EntsoeProtocol) agentService.getProtocolInstance(agent.id)) != null + assert agentService.getAgent(agent.id).getAgentStatus().orElse(null) == ConnectionStatus.CONNECTED + } + + when: "2 attributes are linked to the same agent with the same zone" + def link1 = new EntsoeAgentLink(agent.id) + link1.setZone("10YBE----------2") + def link2 = new EntsoeAgentLink(agent.id) + link2.setZone("10YBE----------2") + + asset = new ThingAsset("Shared Zone Energy Price Asset") + .setRealm(MASTER_REALM) + .addOrReplaceAttributes( + new Attribute<>("energyPriceOne", NUMBER) + .addOrReplaceMeta(new MetaItem<>(AGENT_LINK, link1)), + new Attribute<>("energyPriceTwo", NUMBER) + .addOrReplaceMeta(new MetaItem<>(AGENT_LINK, link2)) + ) + asset = assetStorageService.merge(asset) + + def refOne = new AttributeRef(asset.id, "energyPriceOne") + def refTwo = new AttributeRef(asset.id, "energyPriceTwo") + def protocol = (EntsoeProtocol) agentService.getProtocolInstance(agent.id) + + and: "both attributes are linked by protocol" + conditions.eventually { + assert protocol.getLinkedAttributes().containsKey(refOne) + assert protocol.getLinkedAttributes().containsKey(refTwo) + } + + and: "the request log is cleared before the explicit polling update" + requestLog.clear() + + and: "a polling update is triggered" + protocol.updateAllLinkedAttributes() + + then: "both attributes receive datapoints and the shared zone is requested only once" + conditions.eventually { + List datapointsOne = assetPredictedDatapointService.getDatapoints(refOne).sort { it.timestamp } + List datapointsTwo = assetPredictedDatapointService.getDatapoints(refTwo).sort { it.timestamp } + + assert datapointsOne.size() == 4 + assert datapointsTwo.size() == 4 + assert datapointsOne.collect { [it.timestamp, it.value] } == datapointsTwo.collect { [it.timestamp, it.value] } + + assert requestLog.count { it.zone == "10YBE----------2" } == 1 + } + + cleanup: "remove created assets and mock client" + if (asset?.id) { + assetStorageService.delete([asset.id]) + } + if (agent?.id) { + assetStorageService.delete([agent.id]) + } + if (EntsoeProtocol.client.get() != null) { + EntsoeProtocol.client.set(null) + } + } + def "ENTSO-E integration test keeps existing predicted datapoints when subsequent poll fetch fails"() { given: "the container environment is started" requestCountByZone.clear() From 01852fd1f111de0cac241963ecdd65d80ec9db92 Mon Sep 17 00:00:00 2001 From: Eric Bariaux <375613+ebariaux@users.noreply.github.com> Date: Mon, 23 Mar 2026 13:17:53 +0100 Subject: [PATCH 06/13] Use proper package --- .../extension/entsoe/agent/protocol/EntsoeProtocol.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java index d5ce906..483e494 100644 --- a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java +++ b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java @@ -237,7 +237,7 @@ protected String buildApiUrl(String zone) { */ protected boolean healthCheck() { String apiUrl = buildApiUrl("10YBE----------2"); - try (Response response = client.get().target(apiUrl).request(javax.ws.rs.core.MediaType.APPLICATION_XML).get()) { + try (Response response = client.get().target(apiUrl).request(jakarta.ws.rs.core.MediaType.APPLICATION_XML).get()) { if (response.getStatus() != 200) { LOG.warning("Health check failed with status: " + response.getStatus()); return false; From eda80dccc61c12e1a289e1cd7aa9ffeaea0e0245 Mon Sep 17 00:00:00 2001 From: Eric Bariaux <375613+ebariaux@users.noreply.github.com> Date: Mon, 23 Mar 2026 13:28:30 +0100 Subject: [PATCH 07/13] Ensure an unexpected exception does not stop the scheduling --- .../entsoe/agent/protocol/EntsoeProtocol.java | 10 ++- .../agent/protocol/EntsoeProtocolTest.groovy | 77 +++++++++++++++++++ 2 files changed, 86 insertions(+), 1 deletion(-) diff --git a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java index 483e494..bae1165 100644 --- a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java +++ b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java @@ -138,13 +138,21 @@ protected synchronized void restartPollingWithInitialDelay() { int pollingMillis = agent.getPollingMillis().orElse(DEFAULT_POLLING_MILLIS); pollingFuture = scheduledExecutorService.scheduleAtFixedRate( - this::updateAllLinkedAttributes, + this::runScheduledUpdate, INITIAL_POLLING_DELAY_MILLIS, pollingMillis, TimeUnit.MILLISECONDS ); } + protected void runScheduledUpdate() { + try { + updateAllLinkedAttributes(); + } catch (RuntimeException e) { + LOG.log(Level.WARNING, e, () -> "Scheduled ENTSO-E polling failed; keeping schedule active"); + } + } + @Override protected void doLinkedAttributeWrite(EntsoeAgentLink agentLink, AttributeEvent event, Object processedValue) { // If some external source wants to write the current value of the attribute, we're OK with that diff --git a/entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy b/entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy index 30ce85a..96eecda 100644 --- a/entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy +++ b/entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy @@ -41,6 +41,7 @@ import spock.util.concurrent.PollingConditions import java.time.Instant import java.time.ZoneId import java.time.format.DateTimeFormatter +import java.util.concurrent.atomic.AtomicInteger import java.util.concurrent.TimeUnit import static org.openremote.model.Constants.MASTER_REALM @@ -1094,4 +1095,80 @@ class EntsoeProtocolTest extends Specification implements ManagerContainerTrait EntsoeProtocol.client.set(null) } } + + def "ENTSO-E scheduled polling continues after RuntimeException in updateAllLinkedAttributes"() { + given: "the container environment is started with a pseudo clock" + requestCountByZone.clear() + def conditions = new PollingConditions(timeout: 10, delay: 0.2) + + def container = startContainer(defaultConfig(), defaultServices()) + setPseudoClock(BEFORE_DATASET_START) + def assetStorageService = container.getService(AssetStorageService.class) + EntsoeAgent agent = null + ThrowingEntsoeProtocol protocol = null + + when: "a protocol schedules polling and the scheduled task throws a RuntimeException" + agent = new EntsoeAgent("ENTSO-E Agent") + .setRealm(MASTER_REALM) + .setSecurityToken("test-token") + agent.getAttributes().getOrCreate(org.openremote.model.asset.agent.Agent.POLLING_MILLIS).setValue(1000) + agent = assetStorageService.merge(agent) + + protocol = new ThrowingEntsoeProtocol(agent) + protocol.start(container) + + and: "the clock advances beyond the initial delay and several polling intervals" + advancePseudoClock(10, TimeUnit.SECONDS, container) + + then: "the scheduled task keeps running on the defined schedule despite failures" + conditions.eventually { + assert protocol.invocationCount.get() >= 3 + assert protocol.pollingFuture != null + assert !protocol.pollingFuture.isDone() + } + + when: "the clock advances further" + advancePseudoClock(10, TimeUnit.SECONDS, container) + + then: "more scheduled executions continue to happen" + conditions.eventually { + assert protocol.invocationCount.get() >= 6 + assert !protocol.pollingFuture.isDone() + } + + cleanup: "cancel the scheduled task and remove created assets" + if (protocol?.pollingFuture != null) { + protocol.pollingFuture.cancel(true) + } + if (agent?.id) { + assetStorageService.delete([agent.id]) + } + if (EntsoeProtocol.client.get() != null) { + EntsoeProtocol.client.set(null) + } + } + + static class ThrowingEntsoeProtocol extends EntsoeProtocol { + final AtomicInteger invocationCount = new AtomicInteger() + + ThrowingEntsoeProtocol(EntsoeAgent agent) { + super(agent) + } + + @Override + protected boolean healthCheck() { + return true + } + + @Override + protected void doStart(org.openremote.model.Container container) throws Exception { + restartPollingWithInitialDelay() + } + + @Override + protected void updateAllLinkedAttributes() { + invocationCount.incrementAndGet() + throw new RuntimeException("Synthetic scheduled polling failure") + } + } } From 676f6c09a668eeee2ad60c5e830b83b44691bf99 Mon Sep 17 00:00:00 2001 From: Eric Bariaux <375613+ebariaux@users.noreply.github.com> Date: Mon, 23 Mar 2026 13:35:20 +0100 Subject: [PATCH 08/13] Harden XML parsing --- .../entsoe/agent/protocol/EntsoeProtocol.java | 25 ++++- .../agent/protocol/EntsoeProtocolTest.groovy | 99 +++++++++++++++++++ 2 files changed, 122 insertions(+), 2 deletions(-) diff --git a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java index bae1165..bb7497f 100644 --- a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java +++ b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java @@ -72,7 +72,7 @@ public class EntsoeProtocol extends AbstractProtocol client = new AtomicReference<>(); private static final JAXBContext PUBLICATION_MARKET_DOCUMENT_CONTEXT = createPublicationMarketDocumentContext(); private static final ThreadLocal PUBLICATION_UNMARSHALLER = ThreadLocal.withInitial(EntsoeProtocol::createPublicationUnmarshaller); - private static final ThreadLocal XML_INPUT_FACTORY = ThreadLocal.withInitial(XMLInputFactory::newFactory); + private static final ThreadLocal XML_INPUT_FACTORY = ThreadLocal.withInitial(EntsoeProtocol::createSecureXmlInputFactory); // Initial delay to allow system to populate agent links private static final int INITIAL_POLLING_DELAY_MILLIS = 3000; // 3 seconds @@ -271,7 +271,7 @@ protected PublicationMarketDocument fetchPricingInformation(String apiUrl) { EntsoeXmlMeta xmlMeta = parseEntsoeXmlMeta(responseXml); if ("Publication_MarketDocument".equals(xmlMeta.rootElement)) { - return (PublicationMarketDocument) PUBLICATION_UNMARSHALLER.get().unmarshal(new StringReader(responseXml)); + return unmarshalPublicationMarketDocument(responseXml); } if ("Acknowledgement_MarketDocument".equals(xmlMeta.rootElement)) { @@ -295,6 +295,18 @@ protected PublicationMarketDocument fetchPricingInformation(String apiUrl) { } } + protected static XMLInputFactory createSecureXmlInputFactory() { + try { + XMLInputFactory factory = XMLInputFactory.newFactory(); + factory.setProperty(XMLInputFactory.SUPPORT_DTD, false); + factory.setProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, false); + factory.setXMLResolver((publicId, systemId, baseUri, namespace) -> null); + return factory; + } catch (Exception e) { + throw new IllegalStateException("Failed to initialise secure XMLInputFactory", e); + } + } + protected static JAXBContext createPublicationMarketDocumentContext() { try { return JAXBContext.newInstance(PublicationMarketDocument.class); @@ -311,6 +323,15 @@ protected static Unmarshaller createPublicationUnmarshaller() { } } + protected PublicationMarketDocument unmarshalPublicationMarketDocument(String xml) throws Exception { + XMLStreamReader reader = XML_INPUT_FACTORY.get().createXMLStreamReader(new StringReader(xml)); + try { + return (PublicationMarketDocument) PUBLICATION_UNMARSHALLER.get().unmarshal(reader); + } finally { + reader.close(); + } + } + protected EntsoeXmlMeta parseEntsoeXmlMeta(String xml) throws Exception { XMLStreamReader reader = XML_INPUT_FACTORY.get().createXMLStreamReader(new StringReader(xml)); String rootElement = null; diff --git a/entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy b/entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy index 96eecda..40c4381 100644 --- a/entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy +++ b/entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy @@ -226,6 +226,31 @@ class EntsoeProtocolTest extends Specification implements ManagerContainerTrait No matching data found for Data item ENERGY_PRICES [12.1.D]. +''' + } else if (zone == "10YXXE---------X") { + content = ''' + +]> + + + 2026-02-16T23:00Z + 2026-02-17T23:00Z + + + + + 2026-02-16T23:00Z + 2026-02-17T23:00Z + + PT15M + + 1 + &xxe; + + + + ''' } else if (zone == "10YGAP---------G") { content = ''' @@ -819,6 +844,79 @@ class EntsoeProtocolTest extends Specification implements ManagerContainerTrait } } + def "ENTSO-E integration test rejects XML with DTD and external entity declarations"() { + given: "the container environment is started" + requestCountByZone.clear() + def conditions = new PollingConditions(timeout: 10, delay: 0.2) + + EntsoeProtocol.initClient() + + if (!EntsoeProtocol.client.get().configuration.isRegistered(mockServer)) { + EntsoeProtocol.client.get().register(mockServer, Integer.MAX_VALUE) + } + + def container = startContainer(defaultConfig(), defaultServices()) + setPseudoClock(BEFORE_DATASET_START) + def assetStorageService = container.getService(AssetStorageService.class) + def assetPredictedDatapointService = container.getService(AssetPredictedDatapointService.class) + def agentService = container.getService(AgentService.class) + EntsoeAgent agent = null + ThingAsset asset = null + + when: "an ENTSO-E agent is created" + agent = new EntsoeAgent("ENTSO-E Agent") + .setRealm(MASTER_REALM) + .setSecurityToken("test-token") + agent = assetStorageService.merge(agent) + + then: "the protocol instance for the agent should be created and connected" + conditions.eventually { + assert agentService.getProtocolInstance(agent.id) != null + assert ((EntsoeProtocol) agentService.getProtocolInstance(agent.id)) != null + assert agentService.getAgent(agent.id).getAgentStatus().orElse(null) == ConnectionStatus.CONNECTED + } + + when: "an attribute is linked to a zone that returns XML with a DTD and external entity" + def unsafeXmlLink = new EntsoeAgentLink(agent.id) + unsafeXmlLink.setZone("10YXXE---------X") + + asset = new ThingAsset("Unsafe XML Zone Asset") + .setRealm(MASTER_REALM) + .addOrReplaceAttributes( + new Attribute<>("energyPrice", NUMBER) + .addOrReplaceMeta(new MetaItem<>(AGENT_LINK, unsafeXmlLink)) + ) + asset = assetStorageService.merge(asset) + + def attributeRef = new AttributeRef(asset.id, "energyPrice") + def protocol = (EntsoeProtocol) agentService.getProtocolInstance(agent.id) + + and: "the attribute is linked by protocol" + conditions.eventually { + assert protocol.getLinkedAttributes().containsKey(attributeRef) + } + + and: "a polling update is triggered" + protocol.updateAllLinkedAttributes() + + then: "the unsafe XML is rejected and no predicted datapoints are written" + conditions.eventually { + List datapoints = assetPredictedDatapointService.getDatapoints(attributeRef) + assert datapoints.isEmpty() + } + + cleanup: "remove created assets and mock client" + if (asset?.id) { + assetStorageService.delete([asset.id]) + } + if (agent?.id) { + assetStorageService.delete([agent.id]) + } + if (EntsoeProtocol.client.get() != null) { + EntsoeProtocol.client.set(null) + } + } + def "ENTSO-E integration test keeps position timing when intermediate point is missing"() { given: "the container environment is started" requestCountByZone.clear() @@ -999,6 +1097,7 @@ class EntsoeProtocolTest extends Specification implements ManagerContainerTrait "10YBE_____-----2" || false "10YNDATA-------A" || true "10YMULTI-------A" || true + "10YXXE---------X" || true } def "ENTSO-E integration test updates requested period range when clock advances by one day"() { From 1c7170a7542c119987b5782b9c575000a9d255a7 Mon Sep 17 00:00:00 2001 From: Eric Bariaux <375613+ebariaux@users.noreply.github.com> Date: Mon, 23 Mar 2026 13:40:12 +0100 Subject: [PATCH 09/13] Better parsing of reason text in case of errors --- .../entsoe/agent/protocol/EntsoeProtocol.java | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java index bb7497f..5b41433 100644 --- a/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java +++ b/entsoe/src/main/java/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocol.java @@ -335,7 +335,7 @@ protected PublicationMarketDocument unmarshalPublicationMarketDocument(String xm protected EntsoeXmlMeta parseEntsoeXmlMeta(String xml) throws Exception { XMLStreamReader reader = XML_INPUT_FACTORY.get().createXMLStreamReader(new StringReader(xml)); String rootElement = null; - String reasonText = null; + StringBuilder reasonTextBuilder = new StringBuilder(); boolean inReason = false; boolean inReasonText = false; @@ -355,8 +355,8 @@ protected EntsoeXmlMeta parseEntsoeXmlMeta(String xml) throws Exception { } } else if (event == XMLStreamConstants.CHARACTERS && inReasonText) { String text = reader.getText(); - if (text != null && !text.isBlank()) { - reasonText = reasonText == null ? text.trim() : reasonText + text.trim(); + if (text != null) { + reasonTextBuilder.append(text); } } else if (event == XMLStreamConstants.END_ELEMENT) { String localName = reader.getLocalName(); @@ -371,6 +371,11 @@ protected EntsoeXmlMeta parseEntsoeXmlMeta(String xml) throws Exception { reader.close(); } + String reasonText = reasonTextBuilder.toString().replaceAll("\\s+", " ").trim(); + if (reasonText.isEmpty()) { + reasonText = null; + } + return new EntsoeXmlMeta(rootElement, reasonText); } From 7095bcc852d0d353f2f4beb4738b8d51f4174887 Mon Sep 17 00:00:00 2001 From: Eric Bariaux <375613+ebariaux@users.noreply.github.com> Date: Mon, 23 Mar 2026 13:50:57 +0100 Subject: [PATCH 10/13] Properly close Resteasy client in test cleanup --- .../agent/protocol/EntsoeProtocolTest.groovy | 53 +++++++------------ 1 file changed, 20 insertions(+), 33 deletions(-) diff --git a/entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy b/entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy index 40c4381..5080284 100644 --- a/entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy +++ b/entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy @@ -420,9 +420,7 @@ class EntsoeProtocolTest extends Specification implements ManagerContainerTrait if (agent?.id) { assetStorageService.delete([agent.id]) } - if (EntsoeProtocol.client.get() != null) { - EntsoeProtocol.client.set(null) - } + closeClient() } def "ENTSO-E integration test filters out points in the past when clock is mid-period"() { @@ -495,9 +493,7 @@ class EntsoeProtocolTest extends Specification implements ManagerContainerTrait if (agent?.id) { assetStorageService.delete([agent.id]) } - if (EntsoeProtocol.client.get() != null) { - EntsoeProtocol.client.set(null) - } + closeClient() } def "ENTSO-E integration test writes predicted datapoints for 2 linked attributes with different zones"() { @@ -587,9 +583,7 @@ class EntsoeProtocolTest extends Specification implements ManagerContainerTrait if (agent?.id) { assetStorageService.delete([agent.id]) } - if (EntsoeProtocol.client.get() != null) { - EntsoeProtocol.client.set(null) - } + closeClient() } def "ENTSO-E integration test fetches a shared zone only once per polling cycle"() { @@ -676,9 +670,7 @@ class EntsoeProtocolTest extends Specification implements ManagerContainerTrait if (agent?.id) { assetStorageService.delete([agent.id]) } - if (EntsoeProtocol.client.get() != null) { - EntsoeProtocol.client.set(null) - } + closeClient() } def "ENTSO-E integration test keeps existing predicted datapoints when subsequent poll fetch fails"() { @@ -766,9 +758,7 @@ class EntsoeProtocolTest extends Specification implements ManagerContainerTrait if (agent?.id) { assetStorageService.delete([agent.id]) } - if (EntsoeProtocol.client.get() != null) { - EntsoeProtocol.client.set(null) - } + closeClient() } def "ENTSO-E integration test handles no-data acknowledgement response cleanly"() { @@ -839,9 +829,7 @@ class EntsoeProtocolTest extends Specification implements ManagerContainerTrait if (agent?.id) { assetStorageService.delete([agent.id]) } - if (EntsoeProtocol.client.get() != null) { - EntsoeProtocol.client.set(null) - } + closeClient() } def "ENTSO-E integration test rejects XML with DTD and external entity declarations"() { @@ -912,9 +900,7 @@ class EntsoeProtocolTest extends Specification implements ManagerContainerTrait if (agent?.id) { assetStorageService.delete([agent.id]) } - if (EntsoeProtocol.client.get() != null) { - EntsoeProtocol.client.set(null) - } + closeClient() } def "ENTSO-E integration test keeps position timing when intermediate point is missing"() { @@ -991,9 +977,7 @@ class EntsoeProtocolTest extends Specification implements ManagerContainerTrait if (agent?.id) { assetStorageService.delete([agent.id]) } - if (EntsoeProtocol.client.get() != null) { - EntsoeProtocol.client.set(null) - } + closeClient() } def "ENTSO-E integration test supports multiple periods in a single timeseries"() { @@ -1072,9 +1056,7 @@ class EntsoeProtocolTest extends Specification implements ManagerContainerTrait if (agent?.id) { assetStorageService.delete([agent.id]) } - if (EntsoeProtocol.client.get() != null) { - EntsoeProtocol.client.set(null) - } + closeClient() } def "ENTSO-E agent link validates zone against EIC regex pattern"() { @@ -1190,9 +1172,7 @@ class EntsoeProtocolTest extends Specification implements ManagerContainerTrait if (agent?.id) { assetStorageService.delete([agent.id]) } - if (EntsoeProtocol.client.get() != null) { - EntsoeProtocol.client.set(null) - } + closeClient() } def "ENTSO-E scheduled polling continues after RuntimeException in updateAllLinkedAttributes"() { @@ -1242,9 +1222,7 @@ class EntsoeProtocolTest extends Specification implements ManagerContainerTrait if (agent?.id) { assetStorageService.delete([agent.id]) } - if (EntsoeProtocol.client.get() != null) { - EntsoeProtocol.client.set(null) - } + closeClient() } static class ThrowingEntsoeProtocol extends EntsoeProtocol { @@ -1270,4 +1248,13 @@ class EntsoeProtocolTest extends Specification implements ManagerContainerTrait throw new RuntimeException("Synthetic scheduled polling failure") } } + + protected static void closeClient() { + synchronized (EntsoeProtocol.client) { + def existingClient = EntsoeProtocol.client.getAndSet(null) + if (existingClient != null) { + existingClient.close() + } + } + } } From 45582d05dca58792bcc9b09f9eef30dde9d0c364 Mon Sep 17 00:00:00 2001 From: Eric Bariaux <375613+ebariaux@users.noreply.github.com> Date: Tue, 24 Mar 2026 10:35:36 +0100 Subject: [PATCH 11/13] Don't run tests for now in CI/CD, the pipeline does not properly setup the stack for tests to run --- .../extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy b/entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy index 5080284..531fc4c 100644 --- a/entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy +++ b/entsoe/src/test/groovy/org/openremote/extension/entsoe/agent/protocol/EntsoeProtocolTest.groovy @@ -34,6 +34,8 @@ import org.openremote.model.attribute.AttributeRef import org.openremote.model.attribute.MetaItem import org.openremote.model.datapoint.ValueDatapoint import org.openremote.test.ManagerContainerTrait +import spock.lang.IgnoreIf +import spock.lang.Issue import spock.lang.Shared import spock.lang.Specification import spock.util.concurrent.PollingConditions @@ -48,6 +50,8 @@ import static org.openremote.model.Constants.MASTER_REALM import static org.openremote.model.value.MetaItemType.AGENT_LINK import static org.openremote.model.value.ValueType.NUMBER +@IgnoreIf({ System.getenv("GITHUB_ACTIONS") == "true" }) +@Issue("https://github.com/openremote/openremote/issues/2599") class EntsoeProtocolTest extends Specification implements ManagerContainerTrait { private static final String DATASET_START = "2026-02-16T23:00:00.000Z" private static final String BEFORE_DATASET_START = "2026-02-16T22:00:00.000Z" From c6e420c9986812e0329082a5a204fd1db20a30d2 Mon Sep 17 00:00:00 2001 From: Eric Bariaux <375613+ebariaux@users.noreply.github.com> Date: Fri, 27 Mar 2026 12:54:59 +0100 Subject: [PATCH 12/13] Add documentation for ENTSO-E agent in this repo --- entsoe/src/docs/entsoe.md | 43 +++++++++++++++++++++ entsoe/src/docs/img/ENTSO-E-agent-link.png | Bin 0 -> 61423 bytes 2 files changed, 43 insertions(+) create mode 100644 entsoe/src/docs/entsoe.md create mode 100644 entsoe/src/docs/img/ENTSO-E-agent-link.png diff --git a/entsoe/src/docs/entsoe.md b/entsoe/src/docs/entsoe.md new file mode 100644 index 0000000..3c19669 --- /dev/null +++ b/entsoe/src/docs/entsoe.md @@ -0,0 +1,43 @@ +--- +sidebar_position: 20 +--- + +# ENTSO-E + +## Introduction + +[ENTSO-E](https://www.entsoe.eu/data/transparency-platform/) is a European transparency platform for the energy market that provides +a large collection of energy related data. + +This agent uses their [REST API](https://documenter.getpostman.com/view/7009892/2s93JtP3F6#3b383df0-ada2-49fe-9a50-98b1bb201c6b) to retrieve the `Energy Prices` (document type A44) data. + +## Prerequisites + +Accessing the REST API requires a security token. You must create an account and request such a token for your own usage. +To do so, follow the process described at [How to get security token? – Transparency Platform](https://transparencyplatform.zendesk.com/hc/en-us/articles/12845911031188-How-to-get-security-token). + +## Agent usage + +### ENTSO-E Agent + +To get access to the data, add an ENTSO-E agent to your configuration. +On the agent, fill-in the `Security token` attribute with the token you got from ENTSO-E (see [Prerequisites](#prerequisites) above). +You can optionally add the `Polling millis` attribute to set the polling frequency. It defaults to 1h. + +### Getting the data + +Retrieved pricing data is stored as predicted datapoints of any compatible asset attribute in your configuration. +Note: Compatible means capable of storing positive or negative decimal numbers i.e. the attribute type must be Number or Big Number. +If the attribute is of a different type a warning log will be generated, predicted datapoints will still be generated +but inconsistencies in the system will occur (e.g. errors while trying to graph the attribute). + +On an attribute of type `Number`, add an `Agent link` configuration (MetaItem). +Select the ENTSO-E agent created above, a `Zone` field will appear. +This indicates the region to fetch data for and must be an [Energy Identification Codes](https://www.entsoe.eu/data/energy-identification-codes-eic/). +[EIC Approved codes](https://www.entsoe.eu/data/energy-identification-codes-eic/eic-approved-codes/) provides a complete list of the available code. +Tip: when searching, be sure to select "All Codes" for the "EIC Type Code" criteria. +You'll for instance find that `10YNL----------L` is the code to use for The Netherlands. + +Make sure to also add the `Has predicted data points` configuration to your attribute. + +![](img/ENTSO-E-agent-link.png) diff --git a/entsoe/src/docs/img/ENTSO-E-agent-link.png b/entsoe/src/docs/img/ENTSO-E-agent-link.png new file mode 100644 index 0000000000000000000000000000000000000000..c7095b73560439fc36a629cbb22934147157dde1 GIT binary patch literal 61423 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 literal 0 HcmV?d00001 From f9099de1257b686dddf0ae28c0da51966d39aff1 Mon Sep 17 00:00:00 2001 From: Wouter Born Date: Fri, 27 Mar 2026 15:18:49 +0100 Subject: [PATCH 13/13] Improve documentation discoverability --- entsoe/{src/docs/entsoe.md => README.md} | 4 ---- entsoe/{src/docs => }/img/ENTSO-E-agent-link.png | Bin 2 files changed, 4 deletions(-) rename entsoe/{src/docs/entsoe.md => README.md} (98%) rename entsoe/{src/docs => }/img/ENTSO-E-agent-link.png (100%) diff --git a/entsoe/src/docs/entsoe.md b/entsoe/README.md similarity index 98% rename from entsoe/src/docs/entsoe.md rename to entsoe/README.md index 3c19669..9e1dcb3 100644 --- a/entsoe/src/docs/entsoe.md +++ b/entsoe/README.md @@ -1,7 +1,3 @@ ---- -sidebar_position: 20 ---- - # ENTSO-E ## Introduction diff --git a/entsoe/src/docs/img/ENTSO-E-agent-link.png b/entsoe/img/ENTSO-E-agent-link.png similarity index 100% rename from entsoe/src/docs/img/ENTSO-E-agent-link.png rename to entsoe/img/ENTSO-E-agent-link.png