[feature] add plugin management and support plugin hot reloading

common/src/main/java/org/apache/hertzbeat/common/constants/PluginType.java

@@ -0,0 +1,29 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hertzbeat.common.constants;
+
+/**
+ * plugin type
+ */
+public enum PluginType {
+
+    /**
+     * do something after alter
+     */
+    POST_ALERT
+}

common/src/main/java/org/apache/hertzbeat/common/entity/dto/PluginUpload.java

@@ -0,0 +1,43 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hertzbeat.common.entity.dto;
+
+
+import jakarta.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.springframework.web.multipart.MultipartFile;
+
+/**
+ * data transfer class for uploading plugins
+ */
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class PluginUpload {
+
+    @NotNull
+    private MultipartFile jarFile;
+
+    @NotNull(message = "Plugin name is required")
+    private String name;
+
+    @NotNull(message = "Enable status is required")
+    private Boolean enableStatus;
+}

common/src/main/java/org/apache/hertzbeat/common/entity/manager/PluginItem.java

@@ -0,0 +1,94 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hertzbeat.common.entity.manager;
+
+import static io.swagger.v3.oas.annotations.media.Schema.AccessMode.READ_ONLY;
+import static io.swagger.v3.oas.annotations.media.Schema.AccessMode.READ_WRITE;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.persistence.Entity;
+import jakarta.persistence.EntityListeners;
+import jakarta.persistence.EnumType;
+import jakarta.persistence.Enumerated;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.Table;
+import java.util.Objects;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.apache.hertzbeat.common.constants.PluginType;
+import org.springframework.data.jpa.domain.support.AuditingEntityListener;
+
+/**
+ * Plugin Entity
+ */
+@Entity
+@Table(name = "hzb_plugin_item")
+@Data
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+@Schema(description = "PluginItem Entity")
+@EntityListeners(AuditingEntityListener.class)
+public class PluginItem {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Schema(title = "Plugin Primary key index ID", example = "87584674384", accessMode = READ_ONLY)
+    private Long id;
+
+    @ManyToOne(fetch = FetchType.LAZY)
+    @JoinColumn(name = "metadata_id")
+    @JsonIgnore
+    private PluginMetadata pluginMetadata;
+
+    @Schema(title = "Plugin implementation class full path", example = "org.apache.hertzbeat.plugin.impl.DemoPluginImpl", accessMode = READ_WRITE)
+    private String classIdentifier;
+
+    @Schema(title = "Plugin type", example = "POST_ALERT", accessMode = READ_WRITE)
+    @Enumerated(EnumType.STRING)
+    private PluginType type;
+
+    public PluginItem(String classIdentifier, PluginType type) {
+        this.classIdentifier = classIdentifier;
+        this.type = type;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        PluginItem that = (PluginItem) o;
+        return Objects.equals(id, that.id) && Objects.equals(classIdentifier, that.classIdentifier) && type == that.type;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, classIdentifier, type);
+    }
+}

common/src/main/java/org/apache/hertzbeat/common/entity/manager/PluginMetadata.java

@@ -0,0 +1,103 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hertzbeat.common.entity.manager;
+
+import static io.swagger.v3.oas.annotations.media.Schema.AccessMode.READ_ONLY;
+import static io.swagger.v3.oas.annotations.media.Schema.AccessMode.READ_WRITE;
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.persistence.CascadeType;
+import jakarta.persistence.Entity;
+import jakarta.persistence.EntityListeners;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.GeneratedValue;
+import jakarta.persistence.GenerationType;
+import jakarta.persistence.Id;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.OneToMany;
+import jakarta.persistence.Table;
+import jakarta.validation.constraints.NotNull;
+import java.time.LocalDateTime;
+import java.util.List;
+import java.util.Objects;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import org.springframework.data.annotation.CreatedBy;
+import org.springframework.data.annotation.CreatedDate;
+import org.springframework.data.jpa.domain.support.AuditingEntityListener;
+
+/**
+ * Plugin Entity
+ */
+@Entity
+@Table(name = "hzb_plugin_metadata")
+@Data
+@Builder
+@AllArgsConstructor
+@NoArgsConstructor
+@Schema(description = "Plugin Entity")
+@EntityListeners(AuditingEntityListener.class)
+public class PluginMetadata {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    @Schema(title = "Plugin Primary key index ID", example = "87584674384", accessMode = READ_ONLY)
+    private Long id;
+
+    @Schema(title = "plugin name", example = "notification plugin", accessMode = READ_WRITE)
+    @NotNull
+    private String name;
+
+    @Schema(title = "Plugin activation status", example = "true", accessMode = READ_WRITE)
+    private Boolean enableStatus;
+
+    @Schema(title = "Jar file path", example = "true", accessMode = READ_WRITE)
+    private String jarFilePath;
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        PluginMetadata that = (PluginMetadata) o;
+        return Objects.equals(id, that.id) && Objects.equals(name, that.name) && Objects.equals(enableStatus, that.enableStatus) && Objects.equals(jarFilePath,
+            that.jarFilePath) && Objects.equals(creator, that.creator) && Objects.equals(gmtCreate, that.gmtCreate);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(id, name, enableStatus, jarFilePath, creator, gmtCreate);
+    }
+
+    @Schema(title = "The creator of this record", example = "tom", accessMode = READ_ONLY)
+    @CreatedBy
+    private String creator;
+
+    @Schema(title = "Record create time", example = "1612198922000", accessMode = READ_ONLY)
+    @CreatedDate
+    private LocalDateTime gmtCreate;
+
+    @OneToMany(targetEntity = PluginItem.class, cascade = CascadeType.ALL, fetch = FetchType.EAGER)
+    @JoinColumn(name = "metadata_id", referencedColumnName = "id")
+    private List<PluginItem> items;
+
+}

manager/src/main/java/org/apache/hertzbeat/manager/component/alerter/DispatcherAlarm.java

@@ -21,7 +21,6 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
-import java.util.ServiceLoader;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.hertzbeat.alert.AlerterWorkerPool;
 import org.apache.hertzbeat.common.entity.alerter.Alert;
@@ -30,6 +29,7 @@
 import org.apache.hertzbeat.common.entity.manager.NoticeTemplate;
 import org.apache.hertzbeat.common.queue.CommonDataQueue;
 import org.apache.hertzbeat.manager.service.NoticeConfigService;
+import org.apache.hertzbeat.manager.service.PluginService;
 import org.apache.hertzbeat.manager.support.exception.AlertNoticeException;
 import org.apache.hertzbeat.manager.support.exception.IgnoreException;
 import org.apache.hertzbeat.plugin.Plugin;
@@ -42,23 +42,26 @@
 @Component
 @Slf4j
 public class DispatcherAlarm implements InitializingBean {
+
     private static final int DISPATCH_THREADS = 3;
 
     private final AlerterWorkerPool workerPool;
     private final CommonDataQueue dataQueue;
     private final NoticeConfigService noticeConfigService;
     private final AlertStoreHandler alertStoreHandler;
     private final Map<Byte, AlertNotifyHandler> alertNotifyHandlerMap;
+    private final PluginService pluginService;
 
     public DispatcherAlarm(AlerterWorkerPool workerPool,
-                           CommonDataQueue dataQueue,
-                           NoticeConfigService noticeConfigService,
-                           AlertStoreHandler alertStoreHandler,
-                           List<AlertNotifyHandler> alertNotifyHandlerList) {
+        CommonDataQueue dataQueue,
+        NoticeConfigService noticeConfigService,
+        AlertStoreHandler alertStoreHandler,
+        List<AlertNotifyHandler> alertNotifyHandlerList, PluginService pluginService) {
         this.workerPool = workerPool;
         this.dataQueue = dataQueue;
         this.noticeConfigService = noticeConfigService;
         this.alertStoreHandler = alertStoreHandler;
+        this.pluginService = pluginService;
         alertNotifyHandlerMap = Maps.newHashMapWithExpectedSize(alertNotifyHandlerList.size());
         alertNotifyHandlerList.forEach(r -> alertNotifyHandlerMap.put(r.type(), r));
     }
@@ -127,11 +130,8 @@ public void run() {
                         alertStoreHandler.store(alert);
                         // Notice distribution
                         sendNotify(alert);
-                        // Execute the plugin
-                        ServiceLoader<Plugin> loader = ServiceLoader.load(Plugin.class, Plugin.class.getClassLoader());
-                        for (Plugin plugin : loader) {
-                            plugin.alert(alert);
-                        }
+                        // Execute the plugin if enable
+                        pluginService.pluginExecute(Plugin.class, plugin -> plugin.alert(alert));
                     }
                 } catch (IgnoreException ignored) {
                 } catch (InterruptedException e) {
@@ -147,14 +147,14 @@ private void sendNotify(Alert alert) {
                 noticeRules.forEach(rule -> {
                     workerPool.executeNotify(() -> {
                         rule.getReceiverId()
-                                .forEach(receiverId -> {
-                                    try {
-                                        sendNoticeMsg(getOneReceiverById(receiverId),
-                                                getOneTemplateById(rule.getTemplateId()), alert);
-                                    } catch (AlertNoticeException e) {
-                                        log.warn("DispatchTask sendNoticeMsg error, message: {}", e.getMessage());
-                                    }
-                                });
+                            .forEach(receiverId -> {
+                                try {
+                                    sendNoticeMsg(getOneReceiverById(receiverId),
+                                        getOneTemplateById(rule.getTemplateId()), alert);
+                                } catch (AlertNoticeException e) {
+                                    log.warn("DispatchTask sendNoticeMsg error, message: {}", e.getMessage());
+                                }
+                            });
                     });
                 });
             });