Remote Events migrated from Spring Bus to Spring Cloud Stream (#2563)

* Remote Events migrated from Spring Bus to Spring Cloud Stream --------- Co-authored-by: vasilchev <vasil.ilchev@bosch.com>
2025-07-30 16:58:00 +03:00
parent 10da0288d9
commit 4a8e60764f
49 changed files with 1147 additions and 461 deletions
--- a/hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/event/EventPublisherHolder.java
+++ b/hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/event/EventPublisherHolder.java
@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2015 Bosch Software Innovations GmbH and others
+ * Copyright (c) 2025 Contributors to the Eclipse Foundation
 *
 * This program and the accompanying materials are made
 * available under the terms of the Eclipse Public License 2.0
@@ -9,63 +9,174 @@
 */
 package org.eclipse.hawkbit.repository.event;

-import lombok.AccessLevel;
-import lombok.Getter;
-import lombok.NoArgsConstructor;
+import java.util.Set;
+
+import jakarta.annotation.PostConstruct;
+
+import lombok.extern.slf4j.Slf4j;
+import org.eclipse.hawkbit.repository.event.remote.AbstractRemoteEvent;
+import org.eclipse.hawkbit.repository.event.remote.CancelTargetAssignmentEvent;
+import org.eclipse.hawkbit.repository.event.remote.MultiActionCancelEvent;
+import org.eclipse.hawkbit.repository.event.remote.MultiActionAssignEvent;
+import org.eclipse.hawkbit.repository.event.remote.TargetAssignDistributionSetEvent;
+import org.eclipse.hawkbit.repository.event.remote.TargetAttributesRequestedEvent;
+import org.eclipse.hawkbit.repository.event.remote.TargetDeletedEvent;
+import org.eclipse.hawkbit.repository.event.remote.entity.TargetCreatedEvent;
+import org.eclipse.hawkbit.repository.event.remote.service.CancelTargetAssignmentServiceEvent;
+import org.eclipse.hawkbit.repository.event.remote.service.MultiActionAssignServiceEvent;
+import org.eclipse.hawkbit.repository.event.remote.service.MultiActionCancelServiceEvent;
+import org.eclipse.hawkbit.repository.event.remote.service.TargetAssignDistributionSetServiceEvent;
+import org.eclipse.hawkbit.repository.event.remote.service.TargetAttributesRequestedServiceEvent;
+import org.eclipse.hawkbit.repository.event.remote.service.TargetCreatedServiceEvent;
+import org.eclipse.hawkbit.repository.event.remote.service.TargetDeletedServiceEvent;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.cloud.bus.BusProperties;
-import org.springframework.cloud.bus.ServiceMatcher;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.cloud.stream.function.StreamBridge;
+import org.springframework.context.ApplicationEvent;
 import org.springframework.context.ApplicationEventPublisher;

-/**
- * A singleton bean which holds the event publisher and service origin id in order to publish remote application events.
- * It can be used in beans not instantiated by spring e.g. JPA entities which cannot be auto-wired.
- */
-@NoArgsConstructor(access = AccessLevel.PRIVATE)
-@SuppressWarnings("java:S6548") // java:S6548 - singleton holder ensures static access to spring resources in some places
+@Slf4j
 public final class EventPublisherHolder {

+    @Value("${org.eclipse.hawkbit.events.remote-enabled:true}")
+    private boolean remoteEventsEnabled;
+    @Value("${org.eclipse.hawkbit.events.remote.destination:fanoutEventChannel}")
+    private String fanoutEventChannel;
+    @Value("${org.eclipse.hawkbit.events.remote-service-enabled:true}")
+    private boolean remoteServiceEventsEnabled;
+    @Value("${org.eclipse.hawkbit.events.remote.service.destination:serviceEventChannel}")
+    private String serviceEventChannel;
+
+
    private static final EventPublisherHolder SINGLETON = new EventPublisherHolder();
+    private ApplicationEventPublisher delegateEventPublisher;
+    private StreamBridge streamBridge;

-    @Getter
-    private ApplicationEventPublisher eventPublisher;
-    private ServiceMatcher serviceMatcher;
-    private BusProperties bus;
-
-    /**
-     * @return the event publisher holder singleton instance
-     */
    public static EventPublisherHolder getInstance() {
        return SINGLETON;
    }

-    @Autowired // spring setter injection
-    public void setApplicationEventPublisher(final ApplicationEventPublisher eventPublisher) {
-        this.eventPublisher = eventPublisher;
-    }
-
-    @Autowired(required = false) // spring setter injection
-    public void setServiceMatcher(final ServiceMatcher serviceMatcher) {
-        this.serviceMatcher = serviceMatcher;
-    }
-
-    @Autowired(required = false) // spring setter injection
-    public void setBusProperties(final BusProperties bus) {
-        this.bus = bus;
-    }
-
-    /**
-     * @return the service origin Id coming either from {@link ServiceMatcher} when available or {@link BusProperties} otherwise.
-     */
-    public String getApplicationId() {
-        String id = null;
-        if (serviceMatcher != null) {
-            id = serviceMatcher.getBusId();
+    @PostConstruct
+    private void validateRemoteEventConfig() {
+        if (remoteEventsEnabled && streamBridge == null) {
+            throw new IllegalStateException("'org.eclipse.hawkbit.events.remote-enabled' is true but streamBridge is not configured. Check if 'spring-cloud-starter-stream-rabbit' dependency is included.");
        }
-        if (id == null && bus != null) {
-            id = bus.getId();
+    }
+
+    public static final Set<Class<?>> SERVICE_EVENTS = Set.of(
+            TargetCreatedEvent.class,
+            TargetDeletedEvent.class,
+            MultiActionAssignEvent.class,
+            MultiActionCancelEvent.class,
+            TargetAssignDistributionSetEvent.class,
+            TargetAttributesRequestedEvent.class,
+            CancelTargetAssignmentEvent.class
+    );
+
+    @Autowired
+    public void setApplicationEventPublisher(final ApplicationEventPublisher delegate) {
+        this.delegateEventPublisher = delegate;
+    }
+
+    @Autowired(required = false)
+    public void setStreamBridge(final StreamBridge streamBridge) {
+        this.streamBridge = streamBridge;
+    }
+
+    public ApplicationEventPublisher getEventPublisher() {
+        return new RoutingEventPublisher(streamBridge, delegateEventPublisher);
+    }
+
+    class RoutingEventPublisher implements ApplicationEventPublisher {
+
+        private final StreamBridge streamBridge;
+        private final ApplicationEventPublisher delegate;
+
+        public RoutingEventPublisher(final StreamBridge streamBridge, final ApplicationEventPublisher delegate) {
+            this.streamBridge = streamBridge;
+            this.delegate = delegate;
+        }
+
+        @Override
+        public void publishEvent(final Object event) {
+            routeEvent(event);
+        }
+
+        @Override
+        public void publishEvent(final ApplicationEvent event) {
+            routeEvent(event);
+        }
+
+        private void routeEvent(Object event) {
+            if (remoteEventsEnabled && event instanceof AbstractRemoteEvent remoteEvent) {
+                // send events to remote nodes
+                publishRemotely(remoteEvent);
+            } else {
+                // publish locally
+                publishLocally(event);
+            }
+        }
+
+        private void publishRemotely(final AbstractRemoteEvent remoteEvent) {
+            streamBridge.send(fanoutEventChannel, remoteEvent);
+
+            // some events need to be processed only by single service replica
+            // wrap the entity event into a service event and send it to the service channel
+            if (shouldForwardAsServiceEvent(remoteEvent)) {
+                final AbstractRemoteEvent serviceEvent = toServiceEvent(remoteEvent);
+                if (serviceEvent != null) {
+                    log.debug("Publishing Service event: {} to remote channel: {}", serviceEvent, serviceEventChannel);
+                    streamBridge.send(serviceEventChannel, serviceEvent);
+                } else {
+                    log.error("No Service event created for: {}. Skipping send Service event to Service channel. {}", remoteEvent.getClass(),
+                            serviceEventChannel);
+                }
+            }
+        }
+
+        private void publishLocally(final Object event) {
+            delegate.publishEvent(event);
+
+            // check if the event should be forwarded as a service event even if it is not a remote event
+            if (shouldForwardAsServiceEvent(event)) {
+                final AbstractRemoteEvent serviceEvent = toServiceEvent((AbstractRemoteEvent) event);
+                if (serviceEvent != null) {
+                    log.debug("Publishing Service event: {} to locally.", serviceEvent);
+                    delegate.publishEvent(serviceEvent);
+                } else {
+                    log.error("No Service event created for: {}. Skipping send Service event locally.", event.getClass());
+                }
+            }
+        }
+
+        /**
+         * Checks if the event should be forwarded as a service event.
+         * If remote service events are enabled and the event is one of the service events,
+         *
+         * @param remoteEvent the event to check whether it should be forwarded as a service event
+         * @return true if the event should be forwarded as a service event, false otherwise
+         */
+        private boolean shouldForwardAsServiceEvent(final Object remoteEvent) {
+            return remoteServiceEventsEnabled && SERVICE_EVENTS.contains(remoteEvent.getClass());
+        }
+
+        private AbstractRemoteEvent toServiceEvent(final AbstractRemoteEvent event) {
+            if (event instanceof TargetAssignDistributionSetEvent targetAssignDistributionSetEvent) {
+                return new TargetAssignDistributionSetServiceEvent(targetAssignDistributionSetEvent);
+            } else if (event instanceof MultiActionAssignEvent multiActionAssignEvent) {
+                return new MultiActionAssignServiceEvent(multiActionAssignEvent);
+            } else if (event instanceof MultiActionCancelEvent multiActionCancelEvent) {
+                return new MultiActionCancelServiceEvent(multiActionCancelEvent);
+            } else if (event instanceof CancelTargetAssignmentEvent cancelTargetAssignmentEvent) {
+                return new CancelTargetAssignmentServiceEvent(cancelTargetAssignmentEvent);
+            } else if (event instanceof TargetDeletedEvent targetDeletedEvent) {
+                return new TargetDeletedServiceEvent(targetDeletedEvent);
+            } else if (event instanceof TargetCreatedEvent targetCreatedEvent) {
+                return new TargetCreatedServiceEvent(targetCreatedEvent);
+            } else if (event instanceof TargetAttributesRequestedEvent targetAttributesRequestedEvent) {
+                return new TargetAttributesRequestedServiceEvent(targetAttributesRequestedEvent);
+            }
+            return null;
        }
-        // due to a bug (?) in Spring Cloud, we cannot pass null for applicationId
-        return id == null ? "" : id;
    }
 }
--- a/hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/event/remote/AbstractRemoteEvent.java
+++ b/hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/event/remote/AbstractRemoteEvent.java
@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.eclipse.hawkbit.repository.event.remote;
+
+import java.util.UUID;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import org.springframework.context.ApplicationEvent;
+
+@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "type")
+@Getter
+@EqualsAndHashCode(callSuper = false)
+@JsonIgnoreProperties(ignoreUnknown = true)
+public abstract class AbstractRemoteEvent extends ApplicationEvent {
+
+    private final String id;
+
+    protected AbstractRemoteEvent() {
+        this("_empty_default_");
+    }
+
+    protected AbstractRemoteEvent(Object source) {
+        super(source);
+        this.id = UUID.randomUUID().toString();
+    }
+}
--- a/hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/event/remote/RemoteTenantAwareEvent.java
+++ b/hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/event/remote/RemoteTenantAwareEvent.java
@@ -10,15 +10,14 @@
 package org.eclipse.hawkbit.repository.event.remote;

 import java.io.Serial;
+import java.util.UUID;

 import lombok.AccessLevel;
 import lombok.EqualsAndHashCode;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.ToString;
-import org.eclipse.hawkbit.repository.event.EventPublisherHolder;
 import org.eclipse.hawkbit.repository.event.TenantAwareEvent;
-import org.springframework.cloud.bus.event.RemoteApplicationEvent;

 /**
 * A distributed tenant aware event. It's the base class of the other
@@ -29,19 +28,21 @@ import org.springframework.cloud.bus.event.RemoteApplicationEvent;
@Getter
@EqualsAndHashCode(callSuper = true)
@ToString(callSuper = true)
-public class RemoteTenantAwareEvent extends RemoteApplicationEvent implements TenantAwareEvent {
+public class RemoteTenantAwareEvent extends AbstractRemoteEvent implements TenantAwareEvent {

    @Serial
    private static final long serialVersionUID = 1L;

    private String tenant;

+    /**
+     * Constructor.
+     *
+     * @param source the for the remote event.
+     * @param tenant the tenant
+     */
    public RemoteTenantAwareEvent(final String tenant, final Object source) {
-        super(source == null ? getApplicationId() : source, getApplicationId(), DEFAULT_DESTINATION_FACTORY.getDestination(null));
+        super(source == null ? UUID.randomUUID() : source);
        this.tenant = tenant;
    }
-
-    private static String getApplicationId() {
-        return EventPublisherHolder.getInstance().getApplicationId();
-    }
 }
--- a/hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/event/remote/service/AbstractServiceRemoteEvent.java
+++ b/hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/event/remote/service/AbstractServiceRemoteEvent.java
@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.eclipse.hawkbit.repository.event.remote.service;
+
+import lombok.Getter;
+import org.eclipse.hawkbit.repository.event.remote.AbstractRemoteEvent;
+
+@Getter
+public abstract class AbstractServiceRemoteEvent<T extends AbstractRemoteEvent> extends AbstractRemoteEvent {
+
+    private final T remoteEvent;
+
+    protected AbstractServiceRemoteEvent(T remoteEvent) {
+        super(remoteEvent == null ? "_empty_source_" : remoteEvent.getSource());
+        this.remoteEvent = remoteEvent;
+    }
+
+}
--- a/hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/event/remote/service/CancelTargetAssignmentServiceEvent.java
+++ b/hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/event/remote/service/CancelTargetAssignmentServiceEvent.java
@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.eclipse.hawkbit.repository.event.remote.service;
+
+import java.io.Serial;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import org.eclipse.hawkbit.repository.event.remote.CancelTargetAssignmentEvent;
+
+/**
+ * Service event for {@link CancelTargetAssignmentEvent}. Event that needs single replica processing
+ */
+public class CancelTargetAssignmentServiceEvent extends AbstractServiceRemoteEvent<CancelTargetAssignmentEvent> {
+
+    @Serial
+    private static final long serialVersionUID = 1L;
+
+
+    @JsonCreator
+    public CancelTargetAssignmentServiceEvent(@JsonProperty("payload") final CancelTargetAssignmentEvent remoteEvent) {
+        super(remoteEvent);
+    }
+}
--- a/hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/event/remote/service/MultiActionAssignServiceEvent.java
+++ b/hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/event/remote/service/MultiActionAssignServiceEvent.java
@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.eclipse.hawkbit.repository.event.remote.service;
+
+import java.io.Serial;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import org.eclipse.hawkbit.repository.event.remote.MultiActionAssignEvent;
+
+/**
+ * Service event for {@link MultiActionAssignEvent}. Event that needs single replica processing
+ */
+public class MultiActionAssignServiceEvent extends AbstractServiceRemoteEvent<MultiActionAssignEvent> {
+
+    @Serial
+    private static final long serialVersionUID = 1L;
+
+
+    @JsonCreator
+    public MultiActionAssignServiceEvent(@JsonProperty("payload") final MultiActionAssignEvent remoteEvent) {
+        super(remoteEvent);
+    }
+}
--- a/hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/event/remote/service/MultiActionCancelServiceEvent.java
+++ b/hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/event/remote/service/MultiActionCancelServiceEvent.java
@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.eclipse.hawkbit.repository.event.remote.service;
+
+import java.io.Serial;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import org.eclipse.hawkbit.repository.event.remote.MultiActionCancelEvent;
+
+/**
+ * Service event for {@link MultiActionCancelEvent}. Event that needs single replica processing
+ */
+public class MultiActionCancelServiceEvent extends AbstractServiceRemoteEvent<MultiActionCancelEvent> {
+
+    @Serial
+    private static final long serialVersionUID = 1L;
+
+
+    @JsonCreator
+    public MultiActionCancelServiceEvent(@JsonProperty("payload") final MultiActionCancelEvent remoteEvent) {
+        super(remoteEvent);
+    }
+}
--- a/hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/event/remote/service/TargetAssignDistributionSetServiceEvent.java
+++ b/hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/event/remote/service/TargetAssignDistributionSetServiceEvent.java
@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.eclipse.hawkbit.repository.event.remote.service;
+
+import java.io.Serial;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import org.eclipse.hawkbit.repository.event.remote.TargetAssignDistributionSetEvent;
+
+/**
+ * Service event for {@link TargetAssignDistributionSetEvent}. Event that needs single replica processing
+ */
+public class TargetAssignDistributionSetServiceEvent extends AbstractServiceRemoteEvent<TargetAssignDistributionSetEvent> {
+
+    @Serial
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * Constructor.
+     *
+     * @param remoteEvent the remote event to group
+     */
+    @JsonCreator
+    public TargetAssignDistributionSetServiceEvent(@JsonProperty("payload") final TargetAssignDistributionSetEvent remoteEvent) {
+        super(remoteEvent);
+    }
+}
--- a/hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/event/remote/service/TargetAttributesRequestedServiceEvent.java
+++ b/hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/event/remote/service/TargetAttributesRequestedServiceEvent.java
@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.eclipse.hawkbit.repository.event.remote.service;
+
+import java.io.Serial;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import org.eclipse.hawkbit.repository.event.remote.TargetAttributesRequestedEvent;
+
+/**
+ * Service event for {@link TargetAttributesRequestedEvent}. Event that needs single replica processing
+ */
+public class TargetAttributesRequestedServiceEvent extends AbstractServiceRemoteEvent<TargetAttributesRequestedEvent> {
+
+    @Serial
+    private static final long serialVersionUID = 1L;
+
+
+    @JsonCreator
+    public TargetAttributesRequestedServiceEvent(@JsonProperty("payload") final TargetAttributesRequestedEvent remoteEvent) {
+        super(remoteEvent);
+    }
+}
--- a/hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/event/remote/service/TargetCreatedServiceEvent.java
+++ b/hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/event/remote/service/TargetCreatedServiceEvent.java
@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.eclipse.hawkbit.repository.event.remote.service;
+
+import java.io.Serial;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import org.eclipse.hawkbit.repository.event.remote.entity.TargetCreatedEvent;
+
+/**
+ * Service event for {@link TargetCreatedEvent}. Event that needs single replica processing
+ */
+public class TargetCreatedServiceEvent extends AbstractServiceRemoteEvent<TargetCreatedEvent> {
+
+    @Serial
+    private static final long serialVersionUID = 1L;
+
+
+    @JsonCreator
+    public TargetCreatedServiceEvent(@JsonProperty("payload") final TargetCreatedEvent remoteEvent) {
+        super(remoteEvent);
+    }
+}
--- a/hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/event/remote/service/TargetDeletedServiceEvent.java
+++ b/hawkbit-repository/hawkbit-repository-api/src/main/java/org/eclipse/hawkbit/repository/event/remote/service/TargetDeletedServiceEvent.java
@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ *
+ * This program and the accompanying materials are made
+ * available under the terms of the Eclipse Public License 2.0
+ * which is available at https://www.eclipse.org/legal/epl-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ */
+package org.eclipse.hawkbit.repository.event.remote.service;
+
+import java.io.Serial;
+
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import org.eclipse.hawkbit.repository.event.remote.TargetDeletedEvent;
+
+/**
+ * Service event for {@link TargetDeletedEvent}. Event that needs single replica processing
+ */
+public class TargetDeletedServiceEvent extends AbstractServiceRemoteEvent<TargetDeletedEvent> {
+
+    @Serial
+    private static final long serialVersionUID = 1L;
+
+
+    @JsonCreator
+    public TargetDeletedServiceEvent(@JsonProperty("payload") final TargetDeletedEvent remoteEvent) {
+        super(remoteEvent);
+    }
+}