From 7f48bf4fe472c6b3d9fc6cee425a0765aac8bb2b Mon Sep 17 00:00:00 2001 From: taojinlong Date: Fri, 28 May 2021 12:19:14 +0800 Subject: [PATCH] =?UTF-8?q?fix:=20=E6=A3=80=E6=B5=8B=E5=90=8C=E6=AD=A5?= =?UTF-8?q?=E4=BB=BB=E5=8A=A1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../io/dataease/base/domain/DatasetTable.java | 2 + .../base/domain/DatasetTableExample.java | 70 +++ .../base/domain/QrtzSchedulerState.java | 17 + .../domain/QrtzSchedulerStateExample.java | 460 ++++++++++++++++++ .../base/domain/QrtzSchedulerStateKey.java | 13 + .../base/mapper/DatasetTableMapper.xml | 28 +- .../base/mapper/QrtzSchedulerStateMapper.java | 31 ++ .../base/mapper/QrtzSchedulerStateMapper.xml | 196 ++++++++ .../datasource/service/DatasourceService.java | 2 +- .../dataease/job/sechedule/DeScheduleJob.java | 1 + .../job/sechedule/ExtractDataJob.java | 2 +- .../service/dataset/DataSetTableService.java | 59 ++- .../service/dataset/ExtractDataService.java | 7 +- .../db/migration/V6__alter_table.sql | 3 +- .../src/views/dataset/data/UpdateInfo.vue | 2 + 15 files changed, 869 insertions(+), 24 deletions(-) create mode 100644 backend/src/main/java/io/dataease/base/domain/QrtzSchedulerState.java create mode 100644 backend/src/main/java/io/dataease/base/domain/QrtzSchedulerStateExample.java create mode 100644 backend/src/main/java/io/dataease/base/domain/QrtzSchedulerStateKey.java create mode 100644 backend/src/main/java/io/dataease/base/mapper/QrtzSchedulerStateMapper.java create mode 100644 backend/src/main/java/io/dataease/base/mapper/QrtzSchedulerStateMapper.xml diff --git a/backend/src/main/java/io/dataease/base/domain/DatasetTable.java b/backend/src/main/java/io/dataease/base/domain/DatasetTable.java index 9a0590bba7..e88c0febff 100644 --- a/backend/src/main/java/io/dataease/base/domain/DatasetTable.java +++ b/backend/src/main/java/io/dataease/base/domain/DatasetTable.java @@ -21,6 +21,8 @@ public class DatasetTable implements Serializable { private Long createTime; + private String qrtzInstance; + private String syncStatus; private String info; diff --git a/backend/src/main/java/io/dataease/base/domain/DatasetTableExample.java b/backend/src/main/java/io/dataease/base/domain/DatasetTableExample.java index b229db8021..b0dad0931d 100644 --- a/backend/src/main/java/io/dataease/base/domain/DatasetTableExample.java +++ b/backend/src/main/java/io/dataease/base/domain/DatasetTableExample.java @@ -644,6 +644,76 @@ public class DatasetTableExample { return (Criteria) this; } + public Criteria andQrtzInstanceIsNull() { + addCriterion("qrtz_instance is null"); + return (Criteria) this; + } + + public Criteria andQrtzInstanceIsNotNull() { + addCriterion("qrtz_instance is not null"); + return (Criteria) this; + } + + public Criteria andQrtzInstanceEqualTo(String value) { + addCriterion("qrtz_instance =", value, "qrtzInstance"); + return (Criteria) this; + } + + public Criteria andQrtzInstanceNotEqualTo(String value) { + addCriterion("qrtz_instance <>", value, "qrtzInstance"); + return (Criteria) this; + } + + public Criteria andQrtzInstanceGreaterThan(String value) { + addCriterion("qrtz_instance >", value, "qrtzInstance"); + return (Criteria) this; + } + + public Criteria andQrtzInstanceGreaterThanOrEqualTo(String value) { + addCriterion("qrtz_instance >=", value, "qrtzInstance"); + return (Criteria) this; + } + + public Criteria andQrtzInstanceLessThan(String value) { + addCriterion("qrtz_instance <", value, "qrtzInstance"); + return (Criteria) this; + } + + public Criteria andQrtzInstanceLessThanOrEqualTo(String value) { + addCriterion("qrtz_instance <=", value, "qrtzInstance"); + return (Criteria) this; + } + + public Criteria andQrtzInstanceLike(String value) { + addCriterion("qrtz_instance like", value, "qrtzInstance"); + return (Criteria) this; + } + + public Criteria andQrtzInstanceNotLike(String value) { + addCriterion("qrtz_instance not like", value, "qrtzInstance"); + return (Criteria) this; + } + + public Criteria andQrtzInstanceIn(List values) { + addCriterion("qrtz_instance in", values, "qrtzInstance"); + return (Criteria) this; + } + + public Criteria andQrtzInstanceNotIn(List values) { + addCriterion("qrtz_instance not in", values, "qrtzInstance"); + return (Criteria) this; + } + + public Criteria andQrtzInstanceBetween(String value1, String value2) { + addCriterion("qrtz_instance between", value1, value2, "qrtzInstance"); + return (Criteria) this; + } + + public Criteria andQrtzInstanceNotBetween(String value1, String value2) { + addCriterion("qrtz_instance not between", value1, value2, "qrtzInstance"); + return (Criteria) this; + } + public Criteria andSyncStatusIsNull() { addCriterion("sync_status is null"); return (Criteria) this; diff --git a/backend/src/main/java/io/dataease/base/domain/QrtzSchedulerState.java b/backend/src/main/java/io/dataease/base/domain/QrtzSchedulerState.java new file mode 100644 index 0000000000..2f12a0640b --- /dev/null +++ b/backend/src/main/java/io/dataease/base/domain/QrtzSchedulerState.java @@ -0,0 +1,17 @@ +package io.dataease.base.domain; + +import java.io.Serializable; +import lombok.Data; +import lombok.EqualsAndHashCode; +import lombok.ToString; + +@Data +@EqualsAndHashCode(callSuper = true) +@ToString(callSuper = true) +public class QrtzSchedulerState extends QrtzSchedulerStateKey implements Serializable { + private Long lastCheckinTime; + + private Long checkinInterval; + + private static final long serialVersionUID = 1L; +} \ No newline at end of file diff --git a/backend/src/main/java/io/dataease/base/domain/QrtzSchedulerStateExample.java b/backend/src/main/java/io/dataease/base/domain/QrtzSchedulerStateExample.java new file mode 100644 index 0000000000..4d94ea4067 --- /dev/null +++ b/backend/src/main/java/io/dataease/base/domain/QrtzSchedulerStateExample.java @@ -0,0 +1,460 @@ +package io.dataease.base.domain; + +import java.util.ArrayList; +import java.util.List; + +public class QrtzSchedulerStateExample { + protected String orderByClause; + + protected boolean distinct; + + protected List oredCriteria; + + public QrtzSchedulerStateExample() { + oredCriteria = new ArrayList(); + } + + public void setOrderByClause(String orderByClause) { + this.orderByClause = orderByClause; + } + + public String getOrderByClause() { + return orderByClause; + } + + public void setDistinct(boolean distinct) { + this.distinct = distinct; + } + + public boolean isDistinct() { + return distinct; + } + + public List getOredCriteria() { + return oredCriteria; + } + + public void or(Criteria criteria) { + oredCriteria.add(criteria); + } + + public Criteria or() { + Criteria criteria = createCriteriaInternal(); + oredCriteria.add(criteria); + return criteria; + } + + public Criteria createCriteria() { + Criteria criteria = createCriteriaInternal(); + if (oredCriteria.size() == 0) { + oredCriteria.add(criteria); + } + return criteria; + } + + protected Criteria createCriteriaInternal() { + Criteria criteria = new Criteria(); + return criteria; + } + + public void clear() { + oredCriteria.clear(); + orderByClause = null; + distinct = false; + } + + protected abstract static class GeneratedCriteria { + protected List criteria; + + protected GeneratedCriteria() { + super(); + criteria = new ArrayList(); + } + + public boolean isValid() { + return criteria.size() > 0; + } + + public List getAllCriteria() { + return criteria; + } + + public List getCriteria() { + return criteria; + } + + protected void addCriterion(String condition) { + if (condition == null) { + throw new RuntimeException("Value for condition cannot be null"); + } + criteria.add(new Criterion(condition)); + } + + protected void addCriterion(String condition, Object value, String property) { + if (value == null) { + throw new RuntimeException("Value for " + property + " cannot be null"); + } + criteria.add(new Criterion(condition, value)); + } + + protected void addCriterion(String condition, Object value1, Object value2, String property) { + if (value1 == null || value2 == null) { + throw new RuntimeException("Between values for " + property + " cannot be null"); + } + criteria.add(new Criterion(condition, value1, value2)); + } + + public Criteria andSchedNameIsNull() { + addCriterion("SCHED_NAME is null"); + return (Criteria) this; + } + + public Criteria andSchedNameIsNotNull() { + addCriterion("SCHED_NAME is not null"); + return (Criteria) this; + } + + public Criteria andSchedNameEqualTo(String value) { + addCriterion("SCHED_NAME =", value, "schedName"); + return (Criteria) this; + } + + public Criteria andSchedNameNotEqualTo(String value) { + addCriterion("SCHED_NAME <>", value, "schedName"); + return (Criteria) this; + } + + public Criteria andSchedNameGreaterThan(String value) { + addCriterion("SCHED_NAME >", value, "schedName"); + return (Criteria) this; + } + + public Criteria andSchedNameGreaterThanOrEqualTo(String value) { + addCriterion("SCHED_NAME >=", value, "schedName"); + return (Criteria) this; + } + + public Criteria andSchedNameLessThan(String value) { + addCriterion("SCHED_NAME <", value, "schedName"); + return (Criteria) this; + } + + public Criteria andSchedNameLessThanOrEqualTo(String value) { + addCriterion("SCHED_NAME <=", value, "schedName"); + return (Criteria) this; + } + + public Criteria andSchedNameLike(String value) { + addCriterion("SCHED_NAME like", value, "schedName"); + return (Criteria) this; + } + + public Criteria andSchedNameNotLike(String value) { + addCriterion("SCHED_NAME not like", value, "schedName"); + return (Criteria) this; + } + + public Criteria andSchedNameIn(List values) { + addCriterion("SCHED_NAME in", values, "schedName"); + return (Criteria) this; + } + + public Criteria andSchedNameNotIn(List values) { + addCriterion("SCHED_NAME not in", values, "schedName"); + return (Criteria) this; + } + + public Criteria andSchedNameBetween(String value1, String value2) { + addCriterion("SCHED_NAME between", value1, value2, "schedName"); + return (Criteria) this; + } + + public Criteria andSchedNameNotBetween(String value1, String value2) { + addCriterion("SCHED_NAME not between", value1, value2, "schedName"); + return (Criteria) this; + } + + public Criteria andInstanceNameIsNull() { + addCriterion("INSTANCE_NAME is null"); + return (Criteria) this; + } + + public Criteria andInstanceNameIsNotNull() { + addCriterion("INSTANCE_NAME is not null"); + return (Criteria) this; + } + + public Criteria andInstanceNameEqualTo(String value) { + addCriterion("INSTANCE_NAME =", value, "instanceName"); + return (Criteria) this; + } + + public Criteria andInstanceNameNotEqualTo(String value) { + addCriterion("INSTANCE_NAME <>", value, "instanceName"); + return (Criteria) this; + } + + public Criteria andInstanceNameGreaterThan(String value) { + addCriterion("INSTANCE_NAME >", value, "instanceName"); + return (Criteria) this; + } + + public Criteria andInstanceNameGreaterThanOrEqualTo(String value) { + addCriterion("INSTANCE_NAME >=", value, "instanceName"); + return (Criteria) this; + } + + public Criteria andInstanceNameLessThan(String value) { + addCriterion("INSTANCE_NAME <", value, "instanceName"); + return (Criteria) this; + } + + public Criteria andInstanceNameLessThanOrEqualTo(String value) { + addCriterion("INSTANCE_NAME <=", value, "instanceName"); + return (Criteria) this; + } + + public Criteria andInstanceNameLike(String value) { + addCriterion("INSTANCE_NAME like", value, "instanceName"); + return (Criteria) this; + } + + public Criteria andInstanceNameNotLike(String value) { + addCriterion("INSTANCE_NAME not like", value, "instanceName"); + return (Criteria) this; + } + + public Criteria andInstanceNameIn(List values) { + addCriterion("INSTANCE_NAME in", values, "instanceName"); + return (Criteria) this; + } + + public Criteria andInstanceNameNotIn(List values) { + addCriterion("INSTANCE_NAME not in", values, "instanceName"); + return (Criteria) this; + } + + public Criteria andInstanceNameBetween(String value1, String value2) { + addCriterion("INSTANCE_NAME between", value1, value2, "instanceName"); + return (Criteria) this; + } + + public Criteria andInstanceNameNotBetween(String value1, String value2) { + addCriterion("INSTANCE_NAME not between", value1, value2, "instanceName"); + return (Criteria) this; + } + + public Criteria andLastCheckinTimeIsNull() { + addCriterion("LAST_CHECKIN_TIME is null"); + return (Criteria) this; + } + + public Criteria andLastCheckinTimeIsNotNull() { + addCriterion("LAST_CHECKIN_TIME is not null"); + return (Criteria) this; + } + + public Criteria andLastCheckinTimeEqualTo(Long value) { + addCriterion("LAST_CHECKIN_TIME =", value, "lastCheckinTime"); + return (Criteria) this; + } + + public Criteria andLastCheckinTimeNotEqualTo(Long value) { + addCriterion("LAST_CHECKIN_TIME <>", value, "lastCheckinTime"); + return (Criteria) this; + } + + public Criteria andLastCheckinTimeGreaterThan(Long value) { + addCriterion("LAST_CHECKIN_TIME >", value, "lastCheckinTime"); + return (Criteria) this; + } + + public Criteria andLastCheckinTimeGreaterThanOrEqualTo(Long value) { + addCriterion("LAST_CHECKIN_TIME >=", value, "lastCheckinTime"); + return (Criteria) this; + } + + public Criteria andLastCheckinTimeLessThan(Long value) { + addCriterion("LAST_CHECKIN_TIME <", value, "lastCheckinTime"); + return (Criteria) this; + } + + public Criteria andLastCheckinTimeLessThanOrEqualTo(Long value) { + addCriterion("LAST_CHECKIN_TIME <=", value, "lastCheckinTime"); + return (Criteria) this; + } + + public Criteria andLastCheckinTimeIn(List values) { + addCriterion("LAST_CHECKIN_TIME in", values, "lastCheckinTime"); + return (Criteria) this; + } + + public Criteria andLastCheckinTimeNotIn(List values) { + addCriterion("LAST_CHECKIN_TIME not in", values, "lastCheckinTime"); + return (Criteria) this; + } + + public Criteria andLastCheckinTimeBetween(Long value1, Long value2) { + addCriterion("LAST_CHECKIN_TIME between", value1, value2, "lastCheckinTime"); + return (Criteria) this; + } + + public Criteria andLastCheckinTimeNotBetween(Long value1, Long value2) { + addCriterion("LAST_CHECKIN_TIME not between", value1, value2, "lastCheckinTime"); + return (Criteria) this; + } + + public Criteria andCheckinIntervalIsNull() { + addCriterion("CHECKIN_INTERVAL is null"); + return (Criteria) this; + } + + public Criteria andCheckinIntervalIsNotNull() { + addCriterion("CHECKIN_INTERVAL is not null"); + return (Criteria) this; + } + + public Criteria andCheckinIntervalEqualTo(Long value) { + addCriterion("CHECKIN_INTERVAL =", value, "checkinInterval"); + return (Criteria) this; + } + + public Criteria andCheckinIntervalNotEqualTo(Long value) { + addCriterion("CHECKIN_INTERVAL <>", value, "checkinInterval"); + return (Criteria) this; + } + + public Criteria andCheckinIntervalGreaterThan(Long value) { + addCriterion("CHECKIN_INTERVAL >", value, "checkinInterval"); + return (Criteria) this; + } + + public Criteria andCheckinIntervalGreaterThanOrEqualTo(Long value) { + addCriterion("CHECKIN_INTERVAL >=", value, "checkinInterval"); + return (Criteria) this; + } + + public Criteria andCheckinIntervalLessThan(Long value) { + addCriterion("CHECKIN_INTERVAL <", value, "checkinInterval"); + return (Criteria) this; + } + + public Criteria andCheckinIntervalLessThanOrEqualTo(Long value) { + addCriterion("CHECKIN_INTERVAL <=", value, "checkinInterval"); + return (Criteria) this; + } + + public Criteria andCheckinIntervalIn(List values) { + addCriterion("CHECKIN_INTERVAL in", values, "checkinInterval"); + return (Criteria) this; + } + + public Criteria andCheckinIntervalNotIn(List values) { + addCriterion("CHECKIN_INTERVAL not in", values, "checkinInterval"); + return (Criteria) this; + } + + public Criteria andCheckinIntervalBetween(Long value1, Long value2) { + addCriterion("CHECKIN_INTERVAL between", value1, value2, "checkinInterval"); + return (Criteria) this; + } + + public Criteria andCheckinIntervalNotBetween(Long value1, Long value2) { + addCriterion("CHECKIN_INTERVAL not between", value1, value2, "checkinInterval"); + return (Criteria) this; + } + } + + public static class Criteria extends GeneratedCriteria { + + protected Criteria() { + super(); + } + } + + public static class Criterion { + private String condition; + + private Object value; + + private Object secondValue; + + private boolean noValue; + + private boolean singleValue; + + private boolean betweenValue; + + private boolean listValue; + + private String typeHandler; + + public String getCondition() { + return condition; + } + + public Object getValue() { + return value; + } + + public Object getSecondValue() { + return secondValue; + } + + public boolean isNoValue() { + return noValue; + } + + public boolean isSingleValue() { + return singleValue; + } + + public boolean isBetweenValue() { + return betweenValue; + } + + public boolean isListValue() { + return listValue; + } + + public String getTypeHandler() { + return typeHandler; + } + + protected Criterion(String condition) { + super(); + this.condition = condition; + this.typeHandler = null; + this.noValue = true; + } + + protected Criterion(String condition, Object value, String typeHandler) { + super(); + this.condition = condition; + this.value = value; + this.typeHandler = typeHandler; + if (value instanceof List) { + this.listValue = true; + } else { + this.singleValue = true; + } + } + + protected Criterion(String condition, Object value) { + this(condition, value, null); + } + + protected Criterion(String condition, Object value, Object secondValue, String typeHandler) { + super(); + this.condition = condition; + this.value = value; + this.secondValue = secondValue; + this.typeHandler = typeHandler; + this.betweenValue = true; + } + + protected Criterion(String condition, Object value, Object secondValue) { + this(condition, value, secondValue, null); + } + } +} \ No newline at end of file diff --git a/backend/src/main/java/io/dataease/base/domain/QrtzSchedulerStateKey.java b/backend/src/main/java/io/dataease/base/domain/QrtzSchedulerStateKey.java new file mode 100644 index 0000000000..40062d56bd --- /dev/null +++ b/backend/src/main/java/io/dataease/base/domain/QrtzSchedulerStateKey.java @@ -0,0 +1,13 @@ +package io.dataease.base.domain; + +import java.io.Serializable; +import lombok.Data; + +@Data +public class QrtzSchedulerStateKey implements Serializable { + private String schedName; + + private String instanceName; + + private static final long serialVersionUID = 1L; +} \ No newline at end of file diff --git a/backend/src/main/java/io/dataease/base/mapper/DatasetTableMapper.xml b/backend/src/main/java/io/dataease/base/mapper/DatasetTableMapper.xml index f465f58ec3..35c7c22c34 100644 --- a/backend/src/main/java/io/dataease/base/mapper/DatasetTableMapper.xml +++ b/backend/src/main/java/io/dataease/base/mapper/DatasetTableMapper.xml @@ -10,6 +10,7 @@ + @@ -74,7 +75,8 @@ - id, `name`, scene_id, data_source_id, `type`, `mode`, create_by, create_time, sync_status + id, `name`, scene_id, data_source_id, `type`, `mode`, create_by, create_time, qrtz_instance, + sync_status info @@ -130,12 +132,12 @@ insert into dataset_table (id, `name`, scene_id, data_source_id, `type`, `mode`, - create_by, create_time, sync_status, - info) + create_by, create_time, qrtz_instance, + sync_status, info) values (#{id,jdbcType=VARCHAR}, #{name,jdbcType=VARCHAR}, #{sceneId,jdbcType=VARCHAR}, #{dataSourceId,jdbcType=VARCHAR}, #{type,jdbcType=VARCHAR}, #{mode,jdbcType=INTEGER}, - #{createBy,jdbcType=VARCHAR}, #{createTime,jdbcType=BIGINT}, #{syncStatus,jdbcType=VARCHAR}, - #{info,jdbcType=LONGVARCHAR}) + #{createBy,jdbcType=VARCHAR}, #{createTime,jdbcType=BIGINT}, #{qrtzInstance,jdbcType=VARCHAR}, + #{syncStatus,jdbcType=VARCHAR}, #{info,jdbcType=LONGVARCHAR}) insert into dataset_table @@ -164,6 +166,9 @@ create_time, + + qrtz_instance, + sync_status, @@ -196,6 +201,9 @@ #{createTime,jdbcType=BIGINT}, + + #{qrtzInstance,jdbcType=VARCHAR}, + #{syncStatus,jdbcType=VARCHAR}, @@ -237,6 +245,9 @@ create_time = #{record.createTime,jdbcType=BIGINT}, + + qrtz_instance = #{record.qrtzInstance,jdbcType=VARCHAR}, + sync_status = #{record.syncStatus,jdbcType=VARCHAR}, @@ -258,6 +269,7 @@ `mode` = #{record.mode,jdbcType=INTEGER}, create_by = #{record.createBy,jdbcType=VARCHAR}, create_time = #{record.createTime,jdbcType=BIGINT}, + qrtz_instance = #{record.qrtzInstance,jdbcType=VARCHAR}, sync_status = #{record.syncStatus,jdbcType=VARCHAR}, info = #{record.info,jdbcType=LONGVARCHAR} @@ -274,6 +286,7 @@ `mode` = #{record.mode,jdbcType=INTEGER}, create_by = #{record.createBy,jdbcType=VARCHAR}, create_time = #{record.createTime,jdbcType=BIGINT}, + qrtz_instance = #{record.qrtzInstance,jdbcType=VARCHAR}, sync_status = #{record.syncStatus,jdbcType=VARCHAR} @@ -303,6 +316,9 @@ create_time = #{createTime,jdbcType=BIGINT}, + + qrtz_instance = #{qrtzInstance,jdbcType=VARCHAR}, + sync_status = #{syncStatus,jdbcType=VARCHAR}, @@ -321,6 +337,7 @@ `mode` = #{mode,jdbcType=INTEGER}, create_by = #{createBy,jdbcType=VARCHAR}, create_time = #{createTime,jdbcType=BIGINT}, + qrtz_instance = #{qrtzInstance,jdbcType=VARCHAR}, sync_status = #{syncStatus,jdbcType=VARCHAR}, info = #{info,jdbcType=LONGVARCHAR} where id = #{id,jdbcType=VARCHAR} @@ -334,6 +351,7 @@ `mode` = #{mode,jdbcType=INTEGER}, create_by = #{createBy,jdbcType=VARCHAR}, create_time = #{createTime,jdbcType=BIGINT}, + qrtz_instance = #{qrtzInstance,jdbcType=VARCHAR}, sync_status = #{syncStatus,jdbcType=VARCHAR} where id = #{id,jdbcType=VARCHAR} diff --git a/backend/src/main/java/io/dataease/base/mapper/QrtzSchedulerStateMapper.java b/backend/src/main/java/io/dataease/base/mapper/QrtzSchedulerStateMapper.java new file mode 100644 index 0000000000..3bff02c107 --- /dev/null +++ b/backend/src/main/java/io/dataease/base/mapper/QrtzSchedulerStateMapper.java @@ -0,0 +1,31 @@ +package io.dataease.base.mapper; + +import io.dataease.base.domain.QrtzSchedulerState; +import io.dataease.base.domain.QrtzSchedulerStateExample; +import io.dataease.base.domain.QrtzSchedulerStateKey; +import java.util.List; +import org.apache.ibatis.annotations.Param; + +public interface QrtzSchedulerStateMapper { + long countByExample(QrtzSchedulerStateExample example); + + int deleteByExample(QrtzSchedulerStateExample example); + + int deleteByPrimaryKey(QrtzSchedulerStateKey key); + + int insert(QrtzSchedulerState record); + + int insertSelective(QrtzSchedulerState record); + + List selectByExample(QrtzSchedulerStateExample example); + + QrtzSchedulerState selectByPrimaryKey(QrtzSchedulerStateKey key); + + int updateByExampleSelective(@Param("record") QrtzSchedulerState record, @Param("example") QrtzSchedulerStateExample example); + + int updateByExample(@Param("record") QrtzSchedulerState record, @Param("example") QrtzSchedulerStateExample example); + + int updateByPrimaryKeySelective(QrtzSchedulerState record); + + int updateByPrimaryKey(QrtzSchedulerState record); +} \ No newline at end of file diff --git a/backend/src/main/java/io/dataease/base/mapper/QrtzSchedulerStateMapper.xml b/backend/src/main/java/io/dataease/base/mapper/QrtzSchedulerStateMapper.xml new file mode 100644 index 0000000000..d6a6ad0b3c --- /dev/null +++ b/backend/src/main/java/io/dataease/base/mapper/QrtzSchedulerStateMapper.xml @@ -0,0 +1,196 @@ + + + + + + + + + + + + + + + + + + and ${criterion.condition} + + + and ${criterion.condition} #{criterion.value} + + + and ${criterion.condition} #{criterion.value} and #{criterion.secondValue} + + + and ${criterion.condition} + + #{listItem} + + + + + + + + + + + + + + + + + + and ${criterion.condition} + + + and ${criterion.condition} #{criterion.value} + + + and ${criterion.condition} #{criterion.value} and #{criterion.secondValue} + + + and ${criterion.condition} + + #{listItem} + + + + + + + + + + + SCHED_NAME, INSTANCE_NAME, LAST_CHECKIN_TIME, CHECKIN_INTERVAL + + + + + delete from qrtz_scheduler_state + where SCHED_NAME = #{schedName,jdbcType=VARCHAR} + and INSTANCE_NAME = #{instanceName,jdbcType=VARCHAR} + + + delete from qrtz_scheduler_state + + + + + + insert into qrtz_scheduler_state (SCHED_NAME, INSTANCE_NAME, LAST_CHECKIN_TIME, + CHECKIN_INTERVAL) + values (#{schedName,jdbcType=VARCHAR}, #{instanceName,jdbcType=VARCHAR}, #{lastCheckinTime,jdbcType=BIGINT}, + #{checkinInterval,jdbcType=BIGINT}) + + + insert into qrtz_scheduler_state + + + SCHED_NAME, + + + INSTANCE_NAME, + + + LAST_CHECKIN_TIME, + + + CHECKIN_INTERVAL, + + + + + #{schedName,jdbcType=VARCHAR}, + + + #{instanceName,jdbcType=VARCHAR}, + + + #{lastCheckinTime,jdbcType=BIGINT}, + + + #{checkinInterval,jdbcType=BIGINT}, + + + + + + update qrtz_scheduler_state + + + SCHED_NAME = #{record.schedName,jdbcType=VARCHAR}, + + + INSTANCE_NAME = #{record.instanceName,jdbcType=VARCHAR}, + + + LAST_CHECKIN_TIME = #{record.lastCheckinTime,jdbcType=BIGINT}, + + + CHECKIN_INTERVAL = #{record.checkinInterval,jdbcType=BIGINT}, + + + + + + + + update qrtz_scheduler_state + set SCHED_NAME = #{record.schedName,jdbcType=VARCHAR}, + INSTANCE_NAME = #{record.instanceName,jdbcType=VARCHAR}, + LAST_CHECKIN_TIME = #{record.lastCheckinTime,jdbcType=BIGINT}, + CHECKIN_INTERVAL = #{record.checkinInterval,jdbcType=BIGINT} + + + + + + update qrtz_scheduler_state + + + LAST_CHECKIN_TIME = #{lastCheckinTime,jdbcType=BIGINT}, + + + CHECKIN_INTERVAL = #{checkinInterval,jdbcType=BIGINT}, + + + where SCHED_NAME = #{schedName,jdbcType=VARCHAR} + and INSTANCE_NAME = #{instanceName,jdbcType=VARCHAR} + + + update qrtz_scheduler_state + set LAST_CHECKIN_TIME = #{lastCheckinTime,jdbcType=BIGINT}, + CHECKIN_INTERVAL = #{checkinInterval,jdbcType=BIGINT} + where SCHED_NAME = #{schedName,jdbcType=VARCHAR} + and INSTANCE_NAME = #{instanceName,jdbcType=VARCHAR} + + \ No newline at end of file diff --git a/backend/src/main/java/io/dataease/datasource/service/DatasourceService.java b/backend/src/main/java/io/dataease/datasource/service/DatasourceService.java index 721f1a6ff4..d151efc6fd 100644 --- a/backend/src/main/java/io/dataease/datasource/service/DatasourceService.java +++ b/backend/src/main/java/io/dataease/datasource/service/DatasourceService.java @@ -145,7 +145,7 @@ public class DatasourceService { DatasourceRequest datasourceRequest = new DatasourceRequest(); datasourceRequest.setDatasource(datasource); datasourceProvider.initDataSource(datasourceRequest); - LogUtil.error("Succsss to init datasource connection pool: " + datasource.getName()); + LogUtil.info("Succsss to init datasource connection pool: " + datasource.getName()); }catch (Exception e){ LogUtil.error("Failed to init datasource connection pool: " + datasource.getName(), e); } diff --git a/backend/src/main/java/io/dataease/job/sechedule/DeScheduleJob.java b/backend/src/main/java/io/dataease/job/sechedule/DeScheduleJob.java index 3fa52a44d3..ecbf81d1e6 100644 --- a/backend/src/main/java/io/dataease/job/sechedule/DeScheduleJob.java +++ b/backend/src/main/java/io/dataease/job/sechedule/DeScheduleJob.java @@ -1,5 +1,6 @@ package io.dataease.job.sechedule; +import com.google.gson.Gson; import io.dataease.commons.utils.LogUtil; import org.quartz.*; diff --git a/backend/src/main/java/io/dataease/job/sechedule/ExtractDataJob.java b/backend/src/main/java/io/dataease/job/sechedule/ExtractDataJob.java index d6411e3b96..b8f03d5a75 100644 --- a/backend/src/main/java/io/dataease/job/sechedule/ExtractDataJob.java +++ b/backend/src/main/java/io/dataease/job/sechedule/ExtractDataJob.java @@ -15,7 +15,7 @@ public class ExtractDataJob extends DeScheduleJob{ @Override void businessExecute(JobExecutionContext context) { - extractDataService.extractData(datasetTableId, taskId, updateType); + extractDataService.extractData(datasetTableId, taskId, updateType, context); } } diff --git a/backend/src/main/java/io/dataease/service/dataset/DataSetTableService.java b/backend/src/main/java/io/dataease/service/dataset/DataSetTableService.java index e2c3910b4d..2e950b79cb 100644 --- a/backend/src/main/java/io/dataease/service/dataset/DataSetTableService.java +++ b/backend/src/main/java/io/dataease/service/dataset/DataSetTableService.java @@ -1,11 +1,10 @@ package io.dataease.service.dataset; +import com.fit2cloud.quartz.anno.QuartzScheduled; import com.google.gson.Gson; import io.dataease.base.domain.*; -import io.dataease.base.mapper.DatasetTableIncrementalConfigMapper; -import io.dataease.base.mapper.DatasetTableMapper; -import io.dataease.base.mapper.DatasourceMapper; +import io.dataease.base.mapper.*; import io.dataease.base.mapper.ext.ExtDataSetTableMapper; import io.dataease.commons.constants.JobStatus; import io.dataease.commons.utils.*; @@ -75,6 +74,10 @@ public class DataSetTableService { private DataSetTableUnionService dataSetTableUnionService; @Resource private DataSetTableTaskLogService dataSetTableTaskLogService; + @Resource + private QrtzSchedulerStateMapper qrtzSchedulerStateMapper; + @Resource + private DatasetTableTaskLogMapper datasetTableTaskLogMapper; @Value("${upload.file.path}") private String path; @@ -106,7 +109,7 @@ public class DataSetTableService { saveTableField(datasetTable); if (StringUtils.equalsIgnoreCase(datasetTable.getType(), "excel")) { commonThreadPool.addTask(() -> { - extractDataService.extractData(datasetTable.getId(), null, "all_scope"); + extractDataService.extractData(datasetTable.getId(), null, "all_scope", null); }); } } @@ -867,22 +870,48 @@ public class DataSetTableService { } public Boolean checkDorisTableIsExists(String id) throws Exception { -// Datasource dorisDatasource = (Datasource) CommonBeanFactory.getBean("DorisDatasource"); -// JdbcProvider jdbcProvider = CommonBeanFactory.getBean(JdbcProvider.class); -// DatasourceRequest datasourceRequest = new DatasourceRequest(); -// datasourceRequest.setDatasource(dorisDatasource); -// QueryProvider qp = ProviderFactory.getQueryProvider(dorisDatasource.getType()); -// datasourceRequest.setQuery(qp.searchTable(DorisTableUtils.dorisName(id))); -// List data = jdbcProvider.getData(datasourceRequest); -// return CollectionUtils.isNotEmpty(data); - return true; + Datasource dorisDatasource = (Datasource) CommonBeanFactory.getBean("DorisDatasource"); + JdbcProvider jdbcProvider = CommonBeanFactory.getBean(JdbcProvider.class); + DatasourceRequest datasourceRequest = new DatasourceRequest(); + datasourceRequest.setDatasource(dorisDatasource); + QueryProvider qp = ProviderFactory.getQueryProvider(dorisDatasource.getType()); + datasourceRequest.setQuery(qp.searchTable(DorisTableUtils.dorisName(id))); + List data = jdbcProvider.getData(datasourceRequest); + return CollectionUtils.isNotEmpty(data); } + @QuartzScheduled(cron = "0 0/3 * * * ?") public void updateDatasetTableStatus(){ - DatasetTable record = new DatasetTable(); - record.setSyncStatus(JobStatus.Completed.name()); + List qrtzSchedulerStates = qrtzSchedulerStateMapper.selectByExample(null); + List activeQrtzInstances = qrtzSchedulerStates.stream().filter(qrtzSchedulerState -> qrtzSchedulerState.getLastCheckinTime() + qrtzSchedulerState.getCheckinInterval() + 1000 > System.currentTimeMillis()).map(QrtzSchedulerStateKey::getInstanceName).collect(Collectors.toList()); + List jobStoppeddDatasetTables = new ArrayList<>(); + DatasetTableExample example = new DatasetTableExample(); example.createCriteria().andSyncStatusEqualTo(JobStatus.Underway.name()); + + datasetTableMapper.selectByExample(example).forEach(datasetTable -> { + if(StringUtils.isEmpty(datasetTable.getQrtzInstance()) || !activeQrtzInstances.contains(datasetTable.getQrtzInstance().substring(0, datasetTable.getQrtzInstance().length() - 13))){ + jobStoppeddDatasetTables.add(datasetTable); + } + }); + + if(CollectionUtils.isEmpty(jobStoppeddDatasetTables)){ + return; + } + + DatasetTable record = new DatasetTable(); + record.setSyncStatus(JobStatus.Completed.name()); + example.clear(); + example.createCriteria().andSyncStatusEqualTo(JobStatus.Underway.name()).andIdIn(jobStoppeddDatasetTables.stream().map(DatasetTable::getId).collect(Collectors.toList())); datasetTableMapper.updateByExampleSelective(record, example); + + DatasetTableTaskLog datasetTableTaskLog = new DatasetTableTaskLog(); + datasetTableTaskLog.setStatus(JobStatus.Error.name()); + datasetTableTaskLog.setInfo("Job stopped due to system error."); + + DatasetTableTaskLogExample datasetTableTaskLogExample = new DatasetTableTaskLogExample(); + datasetTableTaskLogExample.createCriteria().andStatusEqualTo(JobStatus.Underway.name()).andTableIdIn(jobStoppeddDatasetTables.stream().map(DatasetTable::getId).collect(Collectors.toList())); + datasetTableTaskLogMapper.updateByExampleSelective(datasetTableTaskLog, datasetTableTaskLogExample); + } } diff --git a/backend/src/main/java/io/dataease/service/dataset/ExtractDataService.java b/backend/src/main/java/io/dataease/service/dataset/ExtractDataService.java index e953b80976..a0d3510bc3 100644 --- a/backend/src/main/java/io/dataease/service/dataset/ExtractDataService.java +++ b/backend/src/main/java/io/dataease/service/dataset/ExtractDataService.java @@ -63,6 +63,7 @@ import org.pentaho.di.trans.steps.textfileoutput.TextFileOutputMeta; import org.pentaho.di.trans.steps.userdefinedjavaclass.UserDefinedJavaClassDef; import org.pentaho.di.trans.steps.userdefinedjavaclass.UserDefinedJavaClassMeta; import org.pentaho.di.www.SlaveServerJobStatus; +import org.quartz.JobExecutionContext; import org.springframework.beans.factory.annotation.Value; import org.springframework.context.annotation.Lazy; import org.springframework.stereotype.Service; @@ -183,7 +184,7 @@ public class ExtractDataService { return datasetTableMapper.updateByExampleSelective(datasetTable, example) == 0; } - public void extractData(String datasetTableId, String taskId, String type) { + public void extractData(String datasetTableId, String taskId, String type, JobExecutionContext context) { DatasetTable datasetTable = dataSetTableService.get(datasetTableId); if(updateSyncStatus(datasetTable)){ LogUtil.info("Skip synchronization task for table : " + datasetTableId); @@ -193,6 +194,10 @@ public class ExtractDataService { UpdateType updateType = UpdateType.valueOf(type); Datasource datasource = new Datasource(); try { + if(context != null){ + datasetTable.setQrtzInstance(context.getFireInstanceId()); + datasetTableMapper.updateByPrimaryKeySelective(datasetTable); + } if (StringUtils.isNotEmpty(datasetTable.getDataSourceId())) { datasource = datasourceMapper.selectByPrimaryKey(datasetTable.getDataSourceId()); } else { diff --git a/backend/src/main/resources/db/migration/V6__alter_table.sql b/backend/src/main/resources/db/migration/V6__alter_table.sql index 9551f19b98..37106309dd 100644 --- a/backend/src/main/resources/db/migration/V6__alter_table.sql +++ b/backend/src/main/resources/db/migration/V6__alter_table.sql @@ -1 +1,2 @@ -ALTER TABLE `dataease`.`dataset_table` ADD COLUMN `sync_status` VARCHAR(45) NULL AFTER `create_time`; +ALTER TABLE `dataset_table` ADD COLUMN `sync_status` VARCHAR(45) NULL AFTER `create_time`; +ALTER TABLE `dataset_table` ADD COLUMN `qrtz_instance` VARCHAR(1024) NULL AFTER `create_time`; diff --git a/frontend/src/views/dataset/data/UpdateInfo.vue b/frontend/src/views/dataset/data/UpdateInfo.vue index 889b95431f..3723b1cefd 100644 --- a/frontend/src/views/dataset/data/UpdateInfo.vue +++ b/frontend/src/views/dataset/data/UpdateInfo.vue @@ -498,6 +498,7 @@ export default { this.update_task = false this.resetTaskForm() this.listTask() + this.listTaskLog() }) }, deleteTask(task) { @@ -514,6 +515,7 @@ export default { }) this.resetTaskForm() this.listTask() + this.listTaskLog() }) }).catch(() => { })