status
stringclasses 1
value | repo_name
stringclasses 31
values | repo_url
stringclasses 31
values | issue_id
int64 1
104k
| title
stringlengths 4
233
| body
stringlengths 0
186k
⌀ | issue_url
stringlengths 38
56
| pull_url
stringlengths 37
54
| before_fix_sha
stringlengths 40
40
| after_fix_sha
stringlengths 40
40
| report_datetime
timestamp[us, tz=UTC] | language
stringclasses 5
values | commit_datetime
timestamp[us, tz=UTC] | updated_file
stringlengths 7
188
| chunk_content
stringlengths 1
1.03M
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 8,980 | [Bug] [Master] master can repeat processing command | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar issues.
### What happened
Question one : If master online or offline, the other active masters will execute the `updateMasterNodes` method, first initialize param of `MASTER_SLOT` to zero, and then get lock from zookeeper and execute `syncMasterNodes` method serially, it initialize param of `MASTER_SIZE` and `MASTER_SLOT`.
so, during the get lock, the `MASTER_SIZE` and `MASTER_SLOT` of each master is valid and has the same value, so the scan command is likely to be repeated. Even if there is a double-check slot in `command2ProcessInstance`, if it cannot be changed before double-check, it will be repeated.
（如果master上线或下线，会通知其他master执行updateMasterNodes方法，首先会初始化MASTER_SLOT=0 (0是有效值)，然后串行争夺zk锁，抢到锁的才会执行syncMasterNodes，这里才会更改MASTER_SIZE。也就是为抢到锁的其他master的MASTER_SIZE相同，MASTER_SLOT都为0，所以此时扫描的command应该都是一样的。虽然再转为processintance之前有二次校验，但是此时如果还没获取到锁，其实值没变，依旧校验通过，所以会多个master会处理同一command）
Question two: Because the timing of master processing is different, and the data will be deleted when completed, so the master query command that will skip part of the data when getting the next page.
### What you expected to happen
No 1. Do not repeat processing command
No 2. As much as possible, ensure that the order of process instances is generated
### How to reproduce
I am so sorry，I don't have enough nodes to test, I can provide a plan.
1. Prepare four master nodes
2. Sleep for 30 seconds after acquiring the lock
3. Large number of inserts command
### Anything else
_No response_
### Version
dev
### Are you willing to submit PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/8980 | https://github.com/apache/dolphinscheduler/pull/9220 | 7553ae5a1707b1e735b7b192777bda20e454463f | 258285e6bb196439efdf7fa18d536723e779fe4f | 2022-03-18T06:11:01Z | java | 2022-03-27T15:33:30Z | dolphinscheduler-master/src/main/java/org/apache/dolphinscheduler/server/master/registry/ServerNodeManager.java | }
} catch (Exception e) {
logger.error("WorkerNodeInfoAndGroupDbSyncTask error:", e);
}
}
}
/**
* worker group node listener
*/
class WorkerDataListener implements SubscribeListener {
@Override
public void notify(Event event) {
final String path = event.path();
final Type type = event.type();
final String data = event.data();
if (registryClient.isWorkerPath(path)) {
try {
if (type == Type.ADD) {
logger.info("worker group node : {} added.", path);
String group = parseGroup(path);
Collection<String> currentNodes = registryClient.getWorkerGroupNodesDirectly(group);
logger.info("currentNodes : {}", currentNodes);
syncWorkerGroupNodes(group, currentNodes);
} else if (type == Type.REMOVE) {
logger.info("worker group node : {} down.", path);
String group = parseGroup(path);
Collection<String> currentNodes = registryClient.getWorkerGroupNodesDirectly(group);
syncWorkerGroupNodes(group, currentNodes);
alertDao.sendServerStopedAlert(1, path, "WORKER");
} else if (type == Type.UPDATE) { |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 8,980 | [Bug] [Master] master can repeat processing command | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar issues.
### What happened
Question one : If master online or offline, the other active masters will execute the `updateMasterNodes` method, first initialize param of `MASTER_SLOT` to zero, and then get lock from zookeeper and execute `syncMasterNodes` method serially, it initialize param of `MASTER_SIZE` and `MASTER_SLOT`.
so, during the get lock, the `MASTER_SIZE` and `MASTER_SLOT` of each master is valid and has the same value, so the scan command is likely to be repeated. Even if there is a double-check slot in `command2ProcessInstance`, if it cannot be changed before double-check, it will be repeated.
（如果master上线或下线，会通知其他master执行updateMasterNodes方法，首先会初始化MASTER_SLOT=0 (0是有效值)，然后串行争夺zk锁，抢到锁的才会执行syncMasterNodes，这里才会更改MASTER_SIZE。也就是为抢到锁的其他master的MASTER_SIZE相同，MASTER_SLOT都为0，所以此时扫描的command应该都是一样的。虽然再转为processintance之前有二次校验，但是此时如果还没获取到锁，其实值没变，依旧校验通过，所以会多个master会处理同一command）
Question two: Because the timing of master processing is different, and the data will be deleted when completed, so the master query command that will skip part of the data when getting the next page.
### What you expected to happen
No 1. Do not repeat processing command
No 2. As much as possible, ensure that the order of process instances is generated
### How to reproduce
I am so sorry，I don't have enough nodes to test, I can provide a plan.
1. Prepare four master nodes
2. Sleep for 30 seconds after acquiring the lock
3. Large number of inserts command
### Anything else
_No response_
### Version
dev
### Are you willing to submit PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/8980 | https://github.com/apache/dolphinscheduler/pull/9220 | 7553ae5a1707b1e735b7b192777bda20e454463f | 258285e6bb196439efdf7fa18d536723e779fe4f | 2022-03-18T06:11:01Z | java | 2022-03-27T15:33:30Z | dolphinscheduler-master/src/main/java/org/apache/dolphinscheduler/server/master/registry/ServerNodeManager.java | logger.debug("worker group node : {} update, data: {}", path, data);
String group = parseGroup(path);
Collection<String> currentNodes = registryClient.getWorkerGroupNodesDirectly(group);
syncWorkerGroupNodes(group, currentNodes);
String node = parseNode(path);
syncSingleWorkerNodeInfo(node, data);
}
} catch (IllegalArgumentException ex) {
logger.warn(ex.getMessage());
} catch (Exception ex) {
logger.error("WorkerGroupListener capture data change and get data failed", ex);
}
}
}
private String parseGroup(String path) {
String[] parts = path.split("/");
if (parts.length < WORKER_LISTENER_CHECK_LENGTH) {
throw new IllegalArgumentException(String.format("worker group path : %s is not valid, ignore", path));
}
return parts[parts.length - 2];
}
private String parseNode(String path) {
String[] parts = path.split("/");
if (parts.length < WORKER_LISTENER_CHECK_LENGTH) {
throw new IllegalArgumentException(String.format("worker group path : %s is not valid, ignore", path));
}
return parts[parts.length - 1];
}
}
class MasterDataListener implements SubscribeListener { |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 8,980 | [Bug] [Master] master can repeat processing command | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar issues.
### What happened
Question one : If master online or offline, the other active masters will execute the `updateMasterNodes` method, first initialize param of `MASTER_SLOT` to zero, and then get lock from zookeeper and execute `syncMasterNodes` method serially, it initialize param of `MASTER_SIZE` and `MASTER_SLOT`.
so, during the get lock, the `MASTER_SIZE` and `MASTER_SLOT` of each master is valid and has the same value, so the scan command is likely to be repeated. Even if there is a double-check slot in `command2ProcessInstance`, if it cannot be changed before double-check, it will be repeated.
（如果master上线或下线，会通知其他master执行updateMasterNodes方法，首先会初始化MASTER_SLOT=0 (0是有效值)，然后串行争夺zk锁，抢到锁的才会执行syncMasterNodes，这里才会更改MASTER_SIZE。也就是为抢到锁的其他master的MASTER_SIZE相同，MASTER_SLOT都为0，所以此时扫描的command应该都是一样的。虽然再转为processintance之前有二次校验，但是此时如果还没获取到锁，其实值没变，依旧校验通过，所以会多个master会处理同一command）
Question two: Because the timing of master processing is different, and the data will be deleted when completed, so the master query command that will skip part of the data when getting the next page.
### What you expected to happen
No 1. Do not repeat processing command
No 2. As much as possible, ensure that the order of process instances is generated
### How to reproduce
I am so sorry，I don't have enough nodes to test, I can provide a plan.
1. Prepare four master nodes
2. Sleep for 30 seconds after acquiring the lock
3. Large number of inserts command
### Anything else
_No response_
### Version
dev
### Are you willing to submit PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/8980 | https://github.com/apache/dolphinscheduler/pull/9220 | 7553ae5a1707b1e735b7b192777bda20e454463f | 258285e6bb196439efdf7fa18d536723e779fe4f | 2022-03-18T06:11:01Z | java | 2022-03-27T15:33:30Z | dolphinscheduler-master/src/main/java/org/apache/dolphinscheduler/server/master/registry/ServerNodeManager.java | @Override
public void notify(Event event) {
final String path = event.path();
final Type type = event.type();
if (registryClient.isMasterPath(path)) {
try {
if (type.equals(Type.ADD)) {
logger.info("master node : {} added.", path);
updateMasterNodes();
}
if (type.equals(Type.REMOVE)) {
logger.info("master node : {} down.", path);
updateMasterNodes();
alertDao.sendServerStopedAlert(1, path, "MASTER");
}
} catch (Exception ex) {
logger.error("MasterNodeListener capture data change and get data failed.", ex);
}
}
} |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 8,980 | [Bug] [Master] master can repeat processing command | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar issues.
### What happened
Question one : If master online or offline, the other active masters will execute the `updateMasterNodes` method, first initialize param of `MASTER_SLOT` to zero, and then get lock from zookeeper and execute `syncMasterNodes` method serially, it initialize param of `MASTER_SIZE` and `MASTER_SLOT`.
so, during the get lock, the `MASTER_SIZE` and `MASTER_SLOT` of each master is valid and has the same value, so the scan command is likely to be repeated. Even if there is a double-check slot in `command2ProcessInstance`, if it cannot be changed before double-check, it will be repeated.
（如果master上线或下线，会通知其他master执行updateMasterNodes方法，首先会初始化MASTER_SLOT=0 (0是有效值)，然后串行争夺zk锁，抢到锁的才会执行syncMasterNodes，这里才会更改MASTER_SIZE。也就是为抢到锁的其他master的MASTER_SIZE相同，MASTER_SLOT都为0，所以此时扫描的command应该都是一样的。虽然再转为processintance之前有二次校验，但是此时如果还没获取到锁，其实值没变，依旧校验通过，所以会多个master会处理同一command）
Question two: Because the timing of master processing is different, and the data will be deleted when completed, so the master query command that will skip part of the data when getting the next page.
### What you expected to happen
No 1. Do not repeat processing command
No 2. As much as possible, ensure that the order of process instances is generated
### How to reproduce
I am so sorry，I don't have enough nodes to test, I can provide a plan.
1. Prepare four master nodes
2. Sleep for 30 seconds after acquiring the lock
3. Large number of inserts command
### Anything else
_No response_
### Version
dev
### Are you willing to submit PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/8980 | https://github.com/apache/dolphinscheduler/pull/9220 | 7553ae5a1707b1e735b7b192777bda20e454463f | 258285e6bb196439efdf7fa18d536723e779fe4f | 2022-03-18T06:11:01Z | java | 2022-03-27T15:33:30Z | dolphinscheduler-master/src/main/java/org/apache/dolphinscheduler/server/master/registry/ServerNodeManager.java | }
private void updateMasterNodes() {
MASTER_SLOT = 0;
this.masterNodes.clear();
String nodeLock = Constants.REGISTRY_DOLPHINSCHEDULER_LOCK_MASTERS;
try {
registryClient.getLock(nodeLock);
Collection<String> currentNodes = registryClient.getMasterNodesDirectly();
List<Server> masterNodes = registryClient.getServerList(NodeType.MASTER);
syncMasterNodes(currentNodes, masterNodes);
} catch (Exception e) {
logger.error("update master nodes error", e);
} finally {
registryClient.releaseLock(nodeLock);
}
}
/**
* get master nodes
*
* @return master nodes
*/
public Set<String> getMasterNodes() {
masterLock.lock();
try {
return Collections.unmodifiableSet(masterNodes);
} finally {
masterLock.unlock();
}
}
/** |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 8,980 | [Bug] [Master] master can repeat processing command | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar issues.
### What happened
Question one : If master online or offline, the other active masters will execute the `updateMasterNodes` method, first initialize param of `MASTER_SLOT` to zero, and then get lock from zookeeper and execute `syncMasterNodes` method serially, it initialize param of `MASTER_SIZE` and `MASTER_SLOT`.
so, during the get lock, the `MASTER_SIZE` and `MASTER_SLOT` of each master is valid and has the same value, so the scan command is likely to be repeated. Even if there is a double-check slot in `command2ProcessInstance`, if it cannot be changed before double-check, it will be repeated.
（如果master上线或下线，会通知其他master执行updateMasterNodes方法，首先会初始化MASTER_SLOT=0 (0是有效值)，然后串行争夺zk锁，抢到锁的才会执行syncMasterNodes，这里才会更改MASTER_SIZE。也就是为抢到锁的其他master的MASTER_SIZE相同，MASTER_SLOT都为0，所以此时扫描的command应该都是一样的。虽然再转为processintance之前有二次校验，但是此时如果还没获取到锁，其实值没变，依旧校验通过，所以会多个master会处理同一command）
Question two: Because the timing of master processing is different, and the data will be deleted when completed, so the master query command that will skip part of the data when getting the next page.
### What you expected to happen
No 1. Do not repeat processing command
No 2. As much as possible, ensure that the order of process instances is generated
### How to reproduce
I am so sorry，I don't have enough nodes to test, I can provide a plan.
1. Prepare four master nodes
2. Sleep for 30 seconds after acquiring the lock
3. Large number of inserts command
### Anything else
_No response_
### Version
dev
### Are you willing to submit PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/8980 | https://github.com/apache/dolphinscheduler/pull/9220 | 7553ae5a1707b1e735b7b192777bda20e454463f | 258285e6bb196439efdf7fa18d536723e779fe4f | 2022-03-18T06:11:01Z | java | 2022-03-27T15:33:30Z | dolphinscheduler-master/src/main/java/org/apache/dolphinscheduler/server/master/registry/ServerNodeManager.java | * sync master nodes
*
* @param nodes master nodes
*/
private void syncMasterNodes(Collection<String> nodes, List<Server> masterNodes) {
masterLock.lock();
try {
String host = NetUtils.getHost();
this.masterNodes.addAll(nodes);
this.masterPriorityQueue.clear();
this.masterPriorityQueue.putList(masterNodes);
int index = masterPriorityQueue.getIndex(host);
if (index >= 0) {
MASTER_SIZE = nodes.size();
MASTER_SLOT = index;
} else {
logger.warn("current host:{} is not in active master list", host);
}
logger.info("update master nodes, master size: {}, slot: {}", MASTER_SIZE, MASTER_SLOT);
} finally {
masterLock.unlock();
}
}
/**
* sync worker group nodes
*
* @param workerGroup worker group
* @param nodes worker nodes
*/
private void syncWorkerGroupNodes(String workerGroup, Collection<String> nodes) { |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 8,980 | [Bug] [Master] master can repeat processing command | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar issues.
### What happened
Question one : If master online or offline, the other active masters will execute the `updateMasterNodes` method, first initialize param of `MASTER_SLOT` to zero, and then get lock from zookeeper and execute `syncMasterNodes` method serially, it initialize param of `MASTER_SIZE` and `MASTER_SLOT`.
so, during the get lock, the `MASTER_SIZE` and `MASTER_SLOT` of each master is valid and has the same value, so the scan command is likely to be repeated. Even if there is a double-check slot in `command2ProcessInstance`, if it cannot be changed before double-check, it will be repeated.
（如果master上线或下线，会通知其他master执行updateMasterNodes方法，首先会初始化MASTER_SLOT=0 (0是有效值)，然后串行争夺zk锁，抢到锁的才会执行syncMasterNodes，这里才会更改MASTER_SIZE。也就是为抢到锁的其他master的MASTER_SIZE相同，MASTER_SLOT都为0，所以此时扫描的command应该都是一样的。虽然再转为processintance之前有二次校验，但是此时如果还没获取到锁，其实值没变，依旧校验通过，所以会多个master会处理同一command）
Question two: Because the timing of master processing is different, and the data will be deleted when completed, so the master query command that will skip part of the data when getting the next page.
### What you expected to happen
No 1. Do not repeat processing command
No 2. As much as possible, ensure that the order of process instances is generated
### How to reproduce
I am so sorry，I don't have enough nodes to test, I can provide a plan.
1. Prepare four master nodes
2. Sleep for 30 seconds after acquiring the lock
3. Large number of inserts command
### Anything else
_No response_
### Version
dev
### Are you willing to submit PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/8980 | https://github.com/apache/dolphinscheduler/pull/9220 | 7553ae5a1707b1e735b7b192777bda20e454463f | 258285e6bb196439efdf7fa18d536723e779fe4f | 2022-03-18T06:11:01Z | java | 2022-03-27T15:33:30Z | dolphinscheduler-master/src/main/java/org/apache/dolphinscheduler/server/master/registry/ServerNodeManager.java | workerGroupLock.lock();
try {
Set<String> workerNodes = workerGroupNodes.getOrDefault(workerGroup, new HashSet<>());
workerNodes.clear();
workerNodes.addAll(nodes);
workerGroupNodes.put(workerGroup, workerNodes);
} finally {
workerGroupLock.unlock();
}
}
public Map<String, Set<String>> getWorkerGroupNodes() {
return Collections.unmodifiableMap(workerGroupNodes);
}
/**
* get worker group nodes
*
* @param workerGroup workerGroup
* @return worker nodes
*/
public Set<String> getWorkerGroupNodes(String workerGroup) {
workerGroupLock.lock();
try {
if (StringUtils.isEmpty(workerGroup)) {
workerGroup = Constants.DEFAULT_WORKER_GROUP;
}
Set<String> nodes = workerGroupNodes.get(workerGroup);
if (CollectionUtils.isNotEmpty(nodes)) {
return Collections.unmodifiableSet(nodes);
}
return nodes; |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 8,980 | [Bug] [Master] master can repeat processing command | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar issues.
### What happened
Question one : If master online or offline, the other active masters will execute the `updateMasterNodes` method, first initialize param of `MASTER_SLOT` to zero, and then get lock from zookeeper and execute `syncMasterNodes` method serially, it initialize param of `MASTER_SIZE` and `MASTER_SLOT`.
so, during the get lock, the `MASTER_SIZE` and `MASTER_SLOT` of each master is valid and has the same value, so the scan command is likely to be repeated. Even if there is a double-check slot in `command2ProcessInstance`, if it cannot be changed before double-check, it will be repeated.
（如果master上线或下线，会通知其他master执行updateMasterNodes方法，首先会初始化MASTER_SLOT=0 (0是有效值)，然后串行争夺zk锁，抢到锁的才会执行syncMasterNodes，这里才会更改MASTER_SIZE。也就是为抢到锁的其他master的MASTER_SIZE相同，MASTER_SLOT都为0，所以此时扫描的command应该都是一样的。虽然再转为processintance之前有二次校验，但是此时如果还没获取到锁，其实值没变，依旧校验通过，所以会多个master会处理同一command）
Question two: Because the timing of master processing is different, and the data will be deleted when completed, so the master query command that will skip part of the data when getting the next page.
### What you expected to happen
No 1. Do not repeat processing command
No 2. As much as possible, ensure that the order of process instances is generated
### How to reproduce
I am so sorry，I don't have enough nodes to test, I can provide a plan.
1. Prepare four master nodes
2. Sleep for 30 seconds after acquiring the lock
3. Large number of inserts command
### Anything else
_No response_
### Version
dev
### Are you willing to submit PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/8980 | https://github.com/apache/dolphinscheduler/pull/9220 | 7553ae5a1707b1e735b7b192777bda20e454463f | 258285e6bb196439efdf7fa18d536723e779fe4f | 2022-03-18T06:11:01Z | java | 2022-03-27T15:33:30Z | dolphinscheduler-master/src/main/java/org/apache/dolphinscheduler/server/master/registry/ServerNodeManager.java | } finally {
workerGroupLock.unlock();
}
}
/**
* get worker node info
*
* @return worker node info
*/
public Map<String, String> getWorkerNodeInfo() {
return Collections.unmodifiableMap(workerNodeInfo);
}
/**
* get worker node info
*
* @param workerNode worker node
* @return worker node info
*/
public String getWorkerNodeInfo(String workerNode) {
workerNodeInfoLock.lock();
try {
return workerNodeInfo.getOrDefault(workerNode, null);
} finally {
workerNodeInfoLock.unlock();
}
}
/**
* sync worker node info
*
* @param newWorkerNodeInfo new worker node info |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 8,980 | [Bug] [Master] master can repeat processing command | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar issues.
### What happened
Question one : If master online or offline, the other active masters will execute the `updateMasterNodes` method, first initialize param of `MASTER_SLOT` to zero, and then get lock from zookeeper and execute `syncMasterNodes` method serially, it initialize param of `MASTER_SIZE` and `MASTER_SLOT`.
so, during the get lock, the `MASTER_SIZE` and `MASTER_SLOT` of each master is valid and has the same value, so the scan command is likely to be repeated. Even if there is a double-check slot in `command2ProcessInstance`, if it cannot be changed before double-check, it will be repeated.
（如果master上线或下线，会通知其他master执行updateMasterNodes方法，首先会初始化MASTER_SLOT=0 (0是有效值)，然后串行争夺zk锁，抢到锁的才会执行syncMasterNodes，这里才会更改MASTER_SIZE。也就是为抢到锁的其他master的MASTER_SIZE相同，MASTER_SLOT都为0，所以此时扫描的command应该都是一样的。虽然再转为processintance之前有二次校验，但是此时如果还没获取到锁，其实值没变，依旧校验通过，所以会多个master会处理同一command）
Question two: Because the timing of master processing is different, and the data will be deleted when completed, so the master query command that will skip part of the data when getting the next page.
### What you expected to happen
No 1. Do not repeat processing command
No 2. As much as possible, ensure that the order of process instances is generated
### How to reproduce
I am so sorry，I don't have enough nodes to test, I can provide a plan.
1. Prepare four master nodes
2. Sleep for 30 seconds after acquiring the lock
3. Large number of inserts command
### Anything else
_No response_
### Version
dev
### Are you willing to submit PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/8980 | https://github.com/apache/dolphinscheduler/pull/9220 | 7553ae5a1707b1e735b7b192777bda20e454463f | 258285e6bb196439efdf7fa18d536723e779fe4f | 2022-03-18T06:11:01Z | java | 2022-03-27T15:33:30Z | dolphinscheduler-master/src/main/java/org/apache/dolphinscheduler/server/master/registry/ServerNodeManager.java | */
private void syncAllWorkerNodeInfo(Map<String, String> newWorkerNodeInfo) {
workerNodeInfoLock.lock();
try {
workerNodeInfo.clear();
workerNodeInfo.putAll(newWorkerNodeInfo);
} finally {
workerNodeInfoLock.unlock();
}
}
/**
* sync single worker node info
*/
private void syncSingleWorkerNodeInfo(String node, String info) {
workerNodeInfoLock.lock();
try {
workerNodeInfo.put(node, info);
} finally {
workerNodeInfoLock.unlock();
}
}
/**
* destroy
*/
@PreDestroy
public void destroy() {
executorService.shutdownNow();
}
} |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 8,980 | [Bug] [Master] master can repeat processing command | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar issues.
### What happened
Question one : If master online or offline, the other active masters will execute the `updateMasterNodes` method, first initialize param of `MASTER_SLOT` to zero, and then get lock from zookeeper and execute `syncMasterNodes` method serially, it initialize param of `MASTER_SIZE` and `MASTER_SLOT`.
so, during the get lock, the `MASTER_SIZE` and `MASTER_SLOT` of each master is valid and has the same value, so the scan command is likely to be repeated. Even if there is a double-check slot in `command2ProcessInstance`, if it cannot be changed before double-check, it will be repeated.
（如果master上线或下线，会通知其他master执行updateMasterNodes方法，首先会初始化MASTER_SLOT=0 (0是有效值)，然后串行争夺zk锁，抢到锁的才会执行syncMasterNodes，这里才会更改MASTER_SIZE。也就是为抢到锁的其他master的MASTER_SIZE相同，MASTER_SLOT都为0，所以此时扫描的command应该都是一样的。虽然再转为processintance之前有二次校验，但是此时如果还没获取到锁，其实值没变，依旧校验通过，所以会多个master会处理同一command）
Question two: Because the timing of master processing is different, and the data will be deleted when completed, so the master query command that will skip part of the data when getting the next page.
### What you expected to happen
No 1. Do not repeat processing command
No 2. As much as possible, ensure that the order of process instances is generated
### How to reproduce
I am so sorry，I don't have enough nodes to test, I can provide a plan.
1. Prepare four master nodes
2. Sleep for 30 seconds after acquiring the lock
3. Large number of inserts command
### Anything else
_No response_
### Version
dev
### Are you willing to submit PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/8980 | https://github.com/apache/dolphinscheduler/pull/9220 | 7553ae5a1707b1e735b7b192777bda20e454463f | 258285e6bb196439efdf7fa18d536723e779fe4f | 2022-03-18T06:11:01Z | java | 2022-03-27T15:33:30Z | dolphinscheduler-master/src/main/java/org/apache/dolphinscheduler/server/master/runner/MasterSchedulerService.java | /*
* 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.dolphinscheduler.server.master.runner; |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 8,980 | [Bug] [Master] master can repeat processing command | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar issues.
### What happened
Question one : If master online or offline, the other active masters will execute the `updateMasterNodes` method, first initialize param of `MASTER_SLOT` to zero, and then get lock from zookeeper and execute `syncMasterNodes` method serially, it initialize param of `MASTER_SIZE` and `MASTER_SLOT`.
so, during the get lock, the `MASTER_SIZE` and `MASTER_SLOT` of each master is valid and has the same value, so the scan command is likely to be repeated. Even if there is a double-check slot in `command2ProcessInstance`, if it cannot be changed before double-check, it will be repeated.
（如果master上线或下线，会通知其他master执行updateMasterNodes方法，首先会初始化MASTER_SLOT=0 (0是有效值)，然后串行争夺zk锁，抢到锁的才会执行syncMasterNodes，这里才会更改MASTER_SIZE。也就是为抢到锁的其他master的MASTER_SIZE相同，MASTER_SLOT都为0，所以此时扫描的command应该都是一样的。虽然再转为processintance之前有二次校验，但是此时如果还没获取到锁，其实值没变，依旧校验通过，所以会多个master会处理同一command）
Question two: Because the timing of master processing is different, and the data will be deleted when completed, so the master query command that will skip part of the data when getting the next page.
### What you expected to happen
No 1. Do not repeat processing command
No 2. As much as possible, ensure that the order of process instances is generated
### How to reproduce
I am so sorry，I don't have enough nodes to test, I can provide a plan.
1. Prepare four master nodes
2. Sleep for 30 seconds after acquiring the lock
3. Large number of inserts command
### Anything else
_No response_
### Version
dev
### Are you willing to submit PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/8980 | https://github.com/apache/dolphinscheduler/pull/9220 | 7553ae5a1707b1e735b7b192777bda20e454463f | 258285e6bb196439efdf7fa18d536723e779fe4f | 2022-03-18T06:11:01Z | java | 2022-03-27T15:33:30Z | dolphinscheduler-master/src/main/java/org/apache/dolphinscheduler/server/master/runner/MasterSchedulerService.java | import org.apache.dolphinscheduler.common.Constants;
import org.apache.dolphinscheduler.common.thread.Stopper;
import org.apache.dolphinscheduler.common.thread.ThreadUtils;
import org.apache.dolphinscheduler.common.utils.NetUtils;
import org.apache.dolphinscheduler.common.utils.OSUtils;
import org.apache.dolphinscheduler.dao.entity.Command;
import org.apache.dolphinscheduler.dao.entity.ProcessInstance;
import org.apache.dolphinscheduler.remote.NettyRemotingClient;
import org.apache.dolphinscheduler.remote.config.NettyClientConfig;
import org.apache.dolphinscheduler.server.master.cache.ProcessInstanceExecCacheManager;
import org.apache.dolphinscheduler.server.master.config.MasterConfig;
import org.apache.dolphinscheduler.server.master.dispatch.executor.NettyExecutorManager;
import org.apache.dolphinscheduler.server.master.registry.ServerNodeManager;
import org.apache.dolphinscheduler.service.alert.ProcessAlertManager;
import org.apache.dolphinscheduler.service.process.ProcessService;
import org.apache.dolphinscheduler.service.task.TaskPluginManager;
import org.apache.commons.collections4.CollectionUtils;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ThreadPoolExecutor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
* master scheduler thread
*/
@Service |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 8,980 | [Bug] [Master] master can repeat processing command | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar issues.
### What happened
Question one : If master online or offline, the other active masters will execute the `updateMasterNodes` method, first initialize param of `MASTER_SLOT` to zero, and then get lock from zookeeper and execute `syncMasterNodes` method serially, it initialize param of `MASTER_SIZE` and `MASTER_SLOT`.
so, during the get lock, the `MASTER_SIZE` and `MASTER_SLOT` of each master is valid and has the same value, so the scan command is likely to be repeated. Even if there is a double-check slot in `command2ProcessInstance`, if it cannot be changed before double-check, it will be repeated.
（如果master上线或下线，会通知其他master执行updateMasterNodes方法，首先会初始化MASTER_SLOT=0 (0是有效值)，然后串行争夺zk锁，抢到锁的才会执行syncMasterNodes，这里才会更改MASTER_SIZE。也就是为抢到锁的其他master的MASTER_SIZE相同，MASTER_SLOT都为0，所以此时扫描的command应该都是一样的。虽然再转为processintance之前有二次校验，但是此时如果还没获取到锁，其实值没变，依旧校验通过，所以会多个master会处理同一command）
Question two: Because the timing of master processing is different, and the data will be deleted when completed, so the master query command that will skip part of the data when getting the next page.
### What you expected to happen
No 1. Do not repeat processing command
No 2. As much as possible, ensure that the order of process instances is generated
### How to reproduce
I am so sorry，I don't have enough nodes to test, I can provide a plan.
1. Prepare four master nodes
2. Sleep for 30 seconds after acquiring the lock
3. Large number of inserts command
### Anything else
_No response_
### Version
dev
### Are you willing to submit PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/8980 | https://github.com/apache/dolphinscheduler/pull/9220 | 7553ae5a1707b1e735b7b192777bda20e454463f | 258285e6bb196439efdf7fa18d536723e779fe4f | 2022-03-18T06:11:01Z | java | 2022-03-27T15:33:30Z | dolphinscheduler-master/src/main/java/org/apache/dolphinscheduler/server/master/runner/MasterSchedulerService.java | public class MasterSchedulerService extends Thread {
/**
* logger of MasterSchedulerService
*/
private static final Logger logger = LoggerFactory.getLogger(MasterSchedulerService.class);
/**
* dolphinscheduler database interface
*/
@Autowired
private ProcessService processService;
/**
* master config
*/
@Autowired
private MasterConfig masterConfig;
/**
* alert manager
*/
@Autowired
private ProcessAlertManager processAlertManager;
/**
* netty remoting client
*/
private NettyRemotingClient nettyRemotingClient;
@Autowired
NettyExecutorManager nettyExecutorManager;
/**
* master prepare exec service
*/
private ThreadPoolExecutor masterPrepareExecService; |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 8,980 | [Bug] [Master] master can repeat processing command | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar issues.
### What happened
Question one : If master online or offline, the other active masters will execute the `updateMasterNodes` method, first initialize param of `MASTER_SLOT` to zero, and then get lock from zookeeper and execute `syncMasterNodes` method serially, it initialize param of `MASTER_SIZE` and `MASTER_SLOT`.
so, during the get lock, the `MASTER_SIZE` and `MASTER_SLOT` of each master is valid and has the same value, so the scan command is likely to be repeated. Even if there is a double-check slot in `command2ProcessInstance`, if it cannot be changed before double-check, it will be repeated.
（如果master上线或下线，会通知其他master执行updateMasterNodes方法，首先会初始化MASTER_SLOT=0 (0是有效值)，然后串行争夺zk锁，抢到锁的才会执行syncMasterNodes，这里才会更改MASTER_SIZE。也就是为抢到锁的其他master的MASTER_SIZE相同，MASTER_SLOT都为0，所以此时扫描的command应该都是一样的。虽然再转为processintance之前有二次校验，但是此时如果还没获取到锁，其实值没变，依旧校验通过，所以会多个master会处理同一command）
Question two: Because the timing of master processing is different, and the data will be deleted when completed, so the master query command that will skip part of the data when getting the next page.
### What you expected to happen
No 1. Do not repeat processing command
No 2. As much as possible, ensure that the order of process instances is generated
### How to reproduce
I am so sorry，I don't have enough nodes to test, I can provide a plan.
1. Prepare four master nodes
2. Sleep for 30 seconds after acquiring the lock
3. Large number of inserts command
### Anything else
_No response_
### Version
dev
### Are you willing to submit PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/8980 | https://github.com/apache/dolphinscheduler/pull/9220 | 7553ae5a1707b1e735b7b192777bda20e454463f | 258285e6bb196439efdf7fa18d536723e779fe4f | 2022-03-18T06:11:01Z | java | 2022-03-27T15:33:30Z | dolphinscheduler-master/src/main/java/org/apache/dolphinscheduler/server/master/runner/MasterSchedulerService.java | /**
* workflow exec service
*/
@Autowired
private WorkflowExecuteThreadPool workflowExecuteThreadPool;
@Autowired
private ProcessInstanceExecCacheManager processInstanceExecCacheManager;
@Autowired
private StateWheelExecuteThread stateWheelExecuteThread;
@Autowired
private TaskPluginManager taskPluginManager;
/**
* constructor of MasterSchedulerService
*/
public void init() {
this.masterPrepareExecService = (ThreadPoolExecutor) ThreadUtils.newDaemonFixedThreadExecutor("Master-Pre-Exec-Thread", masterConfig.getPreExecThreads());
NettyClientConfig clientConfig = new NettyClientConfig();
this.nettyRemotingClient = new NettyRemotingClient(clientConfig);
}
@Override
public synchronized void start() {
super.setName("MasterSchedulerService");
super.start();
this.stateWheelExecuteThread.start();
}
public void close() {
nettyRemotingClient.close();
logger.info("master schedule service stopped...");
}
/** |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 8,980 | [Bug] [Master] master can repeat processing command | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar issues.
### What happened
Question one : If master online or offline, the other active masters will execute the `updateMasterNodes` method, first initialize param of `MASTER_SLOT` to zero, and then get lock from zookeeper and execute `syncMasterNodes` method serially, it initialize param of `MASTER_SIZE` and `MASTER_SLOT`.
so, during the get lock, the `MASTER_SIZE` and `MASTER_SLOT` of each master is valid and has the same value, so the scan command is likely to be repeated. Even if there is a double-check slot in `command2ProcessInstance`, if it cannot be changed before double-check, it will be repeated.
（如果master上线或下线，会通知其他master执行updateMasterNodes方法，首先会初始化MASTER_SLOT=0 (0是有效值)，然后串行争夺zk锁，抢到锁的才会执行syncMasterNodes，这里才会更改MASTER_SIZE。也就是为抢到锁的其他master的MASTER_SIZE相同，MASTER_SLOT都为0，所以此时扫描的command应该都是一样的。虽然再转为processintance之前有二次校验，但是此时如果还没获取到锁，其实值没变，依旧校验通过，所以会多个master会处理同一command）
Question two: Because the timing of master processing is different, and the data will be deleted when completed, so the master query command that will skip part of the data when getting the next page.
### What you expected to happen
No 1. Do not repeat processing command
No 2. As much as possible, ensure that the order of process instances is generated
### How to reproduce
I am so sorry，I don't have enough nodes to test, I can provide a plan.
1. Prepare four master nodes
2. Sleep for 30 seconds after acquiring the lock
3. Large number of inserts command
### Anything else
_No response_
### Version
dev
### Are you willing to submit PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/8980 | https://github.com/apache/dolphinscheduler/pull/9220 | 7553ae5a1707b1e735b7b192777bda20e454463f | 258285e6bb196439efdf7fa18d536723e779fe4f | 2022-03-18T06:11:01Z | java | 2022-03-27T15:33:30Z | dolphinscheduler-master/src/main/java/org/apache/dolphinscheduler/server/master/runner/MasterSchedulerService.java | * run of MasterSchedulerService
*/
@Override
public void run() {
logger.info("master scheduler started");
while (Stopper.isRunning()) {
try {
boolean runCheckFlag = OSUtils.checkResource(masterConfig.getMaxCpuLoadAvg(), masterConfig.getReservedMemory());
if (!runCheckFlag) {
Thread.sleep(Constants.SLEEP_TIME_MILLIS);
continue;
}
scheduleProcess();
} catch (Exception e) {
logger.error("master scheduler thread error", e);
}
}
}
/**
* 1. get command by slot
* 2. donot handle command if slot is empty
*/
private void scheduleProcess() throws Exception {
List<Command> commands = findCommands();
if (CollectionUtils.isEmpty(commands)) {
Thread.sleep(Constants.SLEEP_TIME_MILLIS);
return;
}
List<ProcessInstance> processInstances = command2ProcessInstance(commands); |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 8,980 | [Bug] [Master] master can repeat processing command | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar issues.
### What happened
Question one : If master online or offline, the other active masters will execute the `updateMasterNodes` method, first initialize param of `MASTER_SLOT` to zero, and then get lock from zookeeper and execute `syncMasterNodes` method serially, it initialize param of `MASTER_SIZE` and `MASTER_SLOT`.
so, during the get lock, the `MASTER_SIZE` and `MASTER_SLOT` of each master is valid and has the same value, so the scan command is likely to be repeated. Even if there is a double-check slot in `command2ProcessInstance`, if it cannot be changed before double-check, it will be repeated.
（如果master上线或下线，会通知其他master执行updateMasterNodes方法，首先会初始化MASTER_SLOT=0 (0是有效值)，然后串行争夺zk锁，抢到锁的才会执行syncMasterNodes，这里才会更改MASTER_SIZE。也就是为抢到锁的其他master的MASTER_SIZE相同，MASTER_SLOT都为0，所以此时扫描的command应该都是一样的。虽然再转为processintance之前有二次校验，但是此时如果还没获取到锁，其实值没变，依旧校验通过，所以会多个master会处理同一command）
Question two: Because the timing of master processing is different, and the data will be deleted when completed, so the master query command that will skip part of the data when getting the next page.
### What you expected to happen
No 1. Do not repeat processing command
No 2. As much as possible, ensure that the order of process instances is generated
### How to reproduce
I am so sorry，I don't have enough nodes to test, I can provide a plan.
1. Prepare four master nodes
2. Sleep for 30 seconds after acquiring the lock
3. Large number of inserts command
### Anything else
_No response_
### Version
dev
### Are you willing to submit PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/8980 | https://github.com/apache/dolphinscheduler/pull/9220 | 7553ae5a1707b1e735b7b192777bda20e454463f | 258285e6bb196439efdf7fa18d536723e779fe4f | 2022-03-18T06:11:01Z | java | 2022-03-27T15:33:30Z | dolphinscheduler-master/src/main/java/org/apache/dolphinscheduler/server/master/runner/MasterSchedulerService.java | if (CollectionUtils.isEmpty(processInstances)) {
return;
}
for (ProcessInstance processInstance : processInstances) {
if (processInstance == null) {
continue;
}
WorkflowExecuteThread workflowExecuteThread = new WorkflowExecuteThread(
processInstance
, processService
, nettyExecutorManager
, processAlertManager
, masterConfig
, stateWheelExecuteThread);
this.processInstanceExecCacheManager.cache(processInstance.getId(), workflowExecuteThread);
if (processInstance.getTimeout() > 0) {
stateWheelExecuteThread.addProcess4TimeoutCheck(processInstance);
}
workflowExecuteThreadPool.startWorkflow(workflowExecuteThread);
}
}
private List<ProcessInstance> command2ProcessInstance(List<Command> commands) {
List<ProcessInstance> processInstances = Collections.synchronizedList(new ArrayList<>(commands.size()));
CountDownLatch latch = new CountDownLatch(commands.size());
for (final Command command : commands) {
masterPrepareExecService.execute(() -> {
try {
if (!slotCheck(command)) {
return; |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 8,980 | [Bug] [Master] master can repeat processing command | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar issues.
### What happened
Question one : If master online or offline, the other active masters will execute the `updateMasterNodes` method, first initialize param of `MASTER_SLOT` to zero, and then get lock from zookeeper and execute `syncMasterNodes` method serially, it initialize param of `MASTER_SIZE` and `MASTER_SLOT`.
so, during the get lock, the `MASTER_SIZE` and `MASTER_SLOT` of each master is valid and has the same value, so the scan command is likely to be repeated. Even if there is a double-check slot in `command2ProcessInstance`, if it cannot be changed before double-check, it will be repeated.
（如果master上线或下线，会通知其他master执行updateMasterNodes方法，首先会初始化MASTER_SLOT=0 (0是有效值)，然后串行争夺zk锁，抢到锁的才会执行syncMasterNodes，这里才会更改MASTER_SIZE。也就是为抢到锁的其他master的MASTER_SIZE相同，MASTER_SLOT都为0，所以此时扫描的command应该都是一样的。虽然再转为processintance之前有二次校验，但是此时如果还没获取到锁，其实值没变，依旧校验通过，所以会多个master会处理同一command）
Question two: Because the timing of master processing is different, and the data will be deleted when completed, so the master query command that will skip part of the data when getting the next page.
### What you expected to happen
No 1. Do not repeat processing command
No 2. As much as possible, ensure that the order of process instances is generated
### How to reproduce
I am so sorry，I don't have enough nodes to test, I can provide a plan.
1. Prepare four master nodes
2. Sleep for 30 seconds after acquiring the lock
3. Large number of inserts command
### Anything else
_No response_
### Version
dev
### Are you willing to submit PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/8980 | https://github.com/apache/dolphinscheduler/pull/9220 | 7553ae5a1707b1e735b7b192777bda20e454463f | 258285e6bb196439efdf7fa18d536723e779fe4f | 2022-03-18T06:11:01Z | java | 2022-03-27T15:33:30Z | dolphinscheduler-master/src/main/java/org/apache/dolphinscheduler/server/master/runner/MasterSchedulerService.java | }
ProcessInstance processInstance = processService.handleCommand(logger,
getLocalAddress(),
command);
if (processInstance != null) {
processInstances.add(processInstance);
logger.info("handle command {} end, create process instance {}", command.getId(), processInstance.getId());
}
} catch (Exception e) {
logger.error("handle command error ", e);
processService.moveToErrorCommand(command, e.toString());
} finally {
latch.countDown();
}
});
}
try {
latch.await();
} catch (InterruptedException e) {
logger.error("countDownLatch await error ", e);
}
return processInstances;
}
private List<Command> findCommands() {
int pageNumber = 0;
int pageSize = masterConfig.getFetchCommandNum();
List<Command> result = new ArrayList<>();
while (Stopper.isRunning()) {
if (ServerNodeManager.getMasterSize() == 0) { |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 8,980 | [Bug] [Master] master can repeat processing command | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar issues.
### What happened
Question one : If master online or offline, the other active masters will execute the `updateMasterNodes` method, first initialize param of `MASTER_SLOT` to zero, and then get lock from zookeeper and execute `syncMasterNodes` method serially, it initialize param of `MASTER_SIZE` and `MASTER_SLOT`.
so, during the get lock, the `MASTER_SIZE` and `MASTER_SLOT` of each master is valid and has the same value, so the scan command is likely to be repeated. Even if there is a double-check slot in `command2ProcessInstance`, if it cannot be changed before double-check, it will be repeated.
（如果master上线或下线，会通知其他master执行updateMasterNodes方法，首先会初始化MASTER_SLOT=0 (0是有效值)，然后串行争夺zk锁，抢到锁的才会执行syncMasterNodes，这里才会更改MASTER_SIZE。也就是为抢到锁的其他master的MASTER_SIZE相同，MASTER_SLOT都为0，所以此时扫描的command应该都是一样的。虽然再转为processintance之前有二次校验，但是此时如果还没获取到锁，其实值没变，依旧校验通过，所以会多个master会处理同一command）
Question two: Because the timing of master processing is different, and the data will be deleted when completed, so the master query command that will skip part of the data when getting the next page.
### What you expected to happen
No 1. Do not repeat processing command
No 2. As much as possible, ensure that the order of process instances is generated
### How to reproduce
I am so sorry，I don't have enough nodes to test, I can provide a plan.
1. Prepare four master nodes
2. Sleep for 30 seconds after acquiring the lock
3. Large number of inserts command
### Anything else
_No response_
### Version
dev
### Are you willing to submit PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/8980 | https://github.com/apache/dolphinscheduler/pull/9220 | 7553ae5a1707b1e735b7b192777bda20e454463f | 258285e6bb196439efdf7fa18d536723e779fe4f | 2022-03-18T06:11:01Z | java | 2022-03-27T15:33:30Z | dolphinscheduler-master/src/main/java/org/apache/dolphinscheduler/server/master/runner/MasterSchedulerService.java | return result;
}
List<Command> commandList = processService.findCommandPage(pageSize, pageNumber);
if (commandList.size() == 0) {
return result;
}
for (Command command : commandList) {
if (slotCheck(command)) {
result.add(command);
}
}
if (CollectionUtils.isNotEmpty(result)) {
logger.info("find {} commands, slot:{}", result.size(), ServerNodeManager.getSlot());
break;
}
pageNumber += 1;
}
return result;
}
private boolean slotCheck(Command command) {
int slot = ServerNodeManager.getSlot();
int masterSize = ServerNodeManager.getMasterSize();
return masterSize != 0 && command.getId() % masterSize == slot;
}
private String getLocalAddress() {
return NetUtils.getAddr(masterConfig.getListenPort());
}
} |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/mapper/CommandMapper.java | /*
* 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.dolphinscheduler.dao.mapper;
import org.apache.dolphinscheduler.dao.entity.Command;
import org.apache.dolphinscheduler.dao.entity.CommandCount;
import org.apache.ibatis.annotations.Param;
import java.util.Date;
import java.util.List;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* command mapper interface
*/
public interface CommandMapper extends BaseMapper<Command> { |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-dao/src/main/java/org/apache/dolphinscheduler/dao/mapper/CommandMapper.java | /**
* count command state
* @param userId userId
* @param startTime startTime
* @param endTime endTime
* @param projectCodeArray projectCodeArray
* @return CommandCount list
*/
List<CommandCount> countCommandState(
@Param("userId") int userId,
@Param("startTime") Date startTime,
@Param("endTime") Date endTime,
@Param("projectCodeArray") Long[] projectCodeArray);
/**
* query command page
* @return
*/
List<Command> queryCommandPage(@Param("limit") int limit, @Param("offset") int offset);
} |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/CommandMapperTest.java | /*
* 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.dolphinscheduler.dao.mapper;
import static org.hamcrest.Matchers.greaterThan;
import static org.hamcrest.Matchers.greaterThanOrEqualTo;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertThat;
import org.apache.dolphinscheduler.common.Constants;
import org.apache.dolphinscheduler.common.enums.CommandType;
import org.apache.dolphinscheduler.common.enums.FailureStrategy;
import org.apache.dolphinscheduler.common.enums.Flag; |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/CommandMapperTest.java | import org.apache.dolphinscheduler.common.enums.Priority;
import org.apache.dolphinscheduler.common.enums.ReleaseState;
import org.apache.dolphinscheduler.common.enums.TaskDependType;
import org.apache.dolphinscheduler.common.enums.WarningType;
import org.apache.dolphinscheduler.common.utils.DateUtils;
import org.apache.dolphinscheduler.dao.BaseDaoTest;
import org.apache.dolphinscheduler.dao.entity.Command;
import org.apache.dolphinscheduler.dao.entity.CommandCount;
import org.apache.dolphinscheduler.dao.entity.ProcessDefinition;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
/**
* command mapper test
*/
public class CommandMapperTest extends BaseDaoTest {
@Autowired
private CommandMapper commandMapper;
@Autowired
private ProcessDefinitionMapper processDefinitionMapper;
/**
* test insert
*/
@Test
public void testInsert() {
Command command = createCommand();
assertThat(command.getId(),greaterThan(0)); |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/CommandMapperTest.java | }
/**
* test select by id
*/
@Test
public void testSelectById() {
Command expectedCommand = createCommand();
Command actualCommand = commandMapper.selectById(expectedCommand.getId());
assertNotNull(actualCommand);
assertEquals(expectedCommand.getProcessDefinitionCode(), actualCommand.getProcessDefinitionCode());
}
/**
* test update
*/
@Test
public void testUpdate() {
Command expectedCommand = createCommand();
expectedCommand.setUpdateTime(DateUtils.getCurrentDate());
commandMapper.updateById(expectedCommand);
Command actualCommand = commandMapper.selectById(expectedCommand.getId());
assertNotNull(actualCommand);
assertEquals(expectedCommand.getUpdateTime(),actualCommand.getUpdateTime());
}
/**
* test delete
*/
@Test
public void testDelete() { |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/CommandMapperTest.java | Command expectedCommand = createCommand();
commandMapper.deleteById(expectedCommand.getId());
Command actualCommand = commandMapper.selectById(expectedCommand.getId());
assertNull(actualCommand);
}
/**
* test query all
*/
@Test
public void testGetAll() {
Integer count = 10;
Map<Integer, Command> commandMap = createCommandMap(count);
List<Command> actualCommands = commandMapper.selectList(null);
assertThat(actualCommands.size(), greaterThanOrEqualTo(count));
}
/**
* test get on command to run
*/
@Test
public void testGetOneToRun() {
ProcessDefinition processDefinition = createProcessDefinition();
createCommand(CommandType.START_PROCESS, processDefinition.getCode());
List<Command> actualCommand = commandMapper.queryCommandPage(1,0);
assertNotNull(actualCommand);
}
/**
* test count command state
*/
@Test
public void testCountCommandState() { |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/CommandMapperTest.java | Integer count = 10;
ProcessDefinition processDefinition = createProcessDefinition();
createCommandMap(count, CommandType.START_PROCESS, processDefinition.getCode());
Long[] projectCodeArray = {processDefinition.getProjectCode()};
Date startTime = DateUtils.stringToDate("2019-12-29 00:10:00");
Date endTime = DateUtils.stringToDate("2019-12-29 23:59:59");
List<CommandCount> actualCommandCounts = commandMapper.countCommandState(0, startTime, endTime, projectCodeArray);
assertThat(actualCommandCounts.size(),greaterThanOrEqualTo(1));
}
/**
* create command map
* @param count map count
* @param commandType comman type
* @param processDefinitionCode process definition code
* @return command map
*/
private CommandCount createCommandMap(
Integer count,
CommandType commandType,
long processDefinitionCode) {
CommandCount commandCount = new CommandCount();
for (int i = 0;i < count;i++) {
createCommand(commandType, processDefinitionCode);
}
commandCount.setCommandType(commandType);
commandCount.setCount(count);
return commandCount;
}
/**
* create process definition |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/CommandMapperTest.java | * @return process definition
*/
private ProcessDefinition createProcessDefinition() {
ProcessDefinition processDefinition = new ProcessDefinition();
processDefinition.setCode(1L);
processDefinition.setReleaseState(ReleaseState.ONLINE);
processDefinition.setName("ut test");
processDefinition.setProjectCode(1L);
processDefinition.setFlag(Flag.YES);
processDefinition.setCreateTime(new Date());
processDefinition.setUpdateTime(new Date());
processDefinitionMapper.insert(processDefinition);
return processDefinition;
}
/**
* create command map
* @param count map count
* @return command map
*/
private Map<Integer,Command> createCommandMap(Integer count) {
Map<Integer,Command> commandMap = new HashMap<>();
for (int i = 0;i < count;i++) {
Command command = createCommand();
commandMap.put(command.getId(),command);
}
return commandMap;
}
/**
* create command
* @return |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-dao/src/test/java/org/apache/dolphinscheduler/dao/mapper/CommandMapperTest.java | */
private Command createCommand() {
return createCommand(CommandType.START_PROCESS,1);
}
/**
* create command
* @return Command
*/
private Command createCommand(CommandType commandType, long processDefinitionCode) {
Command command = new Command();
command.setCommandType(commandType);
command.setProcessDefinitionCode(processDefinitionCode);
command.setExecutorId(4);
command.setCommandParam("test command param");
command.setTaskDependType(TaskDependType.TASK_ONLY);
command.setFailureStrategy(FailureStrategy.CONTINUE);
command.setWarningType(WarningType.ALL);
command.setWarningGroupId(1);
command.setScheduleTime(DateUtils.stringToDate("2019-12-29 12:10:00"));
command.setProcessInstancePriority(Priority.MEDIUM);
command.setStartTime(DateUtils.stringToDate("2019-12-29 10:10:00"));
command.setUpdateTime(DateUtils.stringToDate("2019-12-29 10:10:00"));
command.setWorkerGroup(Constants.DEFAULT_WORKER_GROUP);
command.setProcessInstanceId(0);
command.setProcessDefinitionVersion(0);
commandMapper.insert(command);
return command;
}
} |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-master/src/main/java/org/apache/dolphinscheduler/server/master/runner/MasterSchedulerService.java | /*
* 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.dolphinscheduler.server.master.runner;
import org.apache.dolphinscheduler.common.Constants;
import org.apache.dolphinscheduler.common.enums.SlotCheckState;
import org.apache.dolphinscheduler.common.thread.Stopper;
import org.apache.dolphinscheduler.common.thread.ThreadUtils;
import org.apache.dolphinscheduler.common.utils.NetUtils;
import org.apache.dolphinscheduler.common.utils.OSUtils;
import org.apache.dolphinscheduler.dao.entity.Command;
import org.apache.dolphinscheduler.dao.entity.ProcessInstance;
import org.apache.dolphinscheduler.remote.NettyRemotingClient;
import org.apache.dolphinscheduler.remote.config.NettyClientConfig;
import org.apache.dolphinscheduler.server.master.cache.ProcessInstanceExecCacheManager;
import org.apache.dolphinscheduler.server.master.config.MasterConfig;
import org.apache.dolphinscheduler.server.master.dispatch.executor.NettyExecutorManager; |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-master/src/main/java/org/apache/dolphinscheduler/server/master/runner/MasterSchedulerService.java | import org.apache.dolphinscheduler.server.master.registry.ServerNodeManager;
import org.apache.dolphinscheduler.service.alert.ProcessAlertManager;
import org.apache.dolphinscheduler.service.process.ProcessService;
import org.apache.dolphinscheduler.service.task.TaskPluginManager;
import org.apache.commons.collections4.CollectionUtils;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ThreadPoolExecutor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
* master scheduler thread
*/
@Service
public class MasterSchedulerService extends Thread {
/**
* logger of MasterSchedulerService
*/
private static final Logger logger = LoggerFactory.getLogger(MasterSchedulerService.class);
/**
* dolphinscheduler database interface
*/
@Autowired
private ProcessService processService;
/**
* master config |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-master/src/main/java/org/apache/dolphinscheduler/server/master/runner/MasterSchedulerService.java | */
@Autowired
private MasterConfig masterConfig;
/**
* alert manager
*/
@Autowired
private ProcessAlertManager processAlertManager;
/**
* netty remoting client
*/
private NettyRemotingClient nettyRemotingClient;
@Autowired
NettyExecutorManager nettyExecutorManager;
/**
* master prepare exec service
*/
private ThreadPoolExecutor masterPrepareExecService;
/**
* workflow exec service
*/
@Autowired
private WorkflowExecuteThreadPool workflowExecuteThreadPool;
@Autowired
private ProcessInstanceExecCacheManager processInstanceExecCacheManager;
@Autowired
private StateWheelExecuteThread stateWheelExecuteThread;
@Autowired
private TaskPluginManager taskPluginManager;
/** |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-master/src/main/java/org/apache/dolphinscheduler/server/master/runner/MasterSchedulerService.java | * constructor of MasterSchedulerService
*/
public void init() {
this.masterPrepareExecService = (ThreadPoolExecutor) ThreadUtils.newDaemonFixedThreadExecutor("Master-Pre-Exec-Thread", masterConfig.getPreExecThreads());
NettyClientConfig clientConfig = new NettyClientConfig();
this.nettyRemotingClient = new NettyRemotingClient(clientConfig);
}
@Override
public synchronized void start() {
super.setName("MasterSchedulerService");
super.start();
this.stateWheelExecuteThread.start();
}
public void close() {
nettyRemotingClient.close();
logger.info("master schedule service stopped...");
}
/**
* run of MasterSchedulerService
*/
@Override
public void run() {
logger.info("master scheduler started");
while (Stopper.isRunning()) {
try {
boolean runCheckFlag = OSUtils.checkResource(masterConfig.getMaxCpuLoadAvg(), masterConfig.getReservedMemory());
if (!runCheckFlag) {
Thread.sleep(Constants.SLEEP_TIME_MILLIS);
continue;
} |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-master/src/main/java/org/apache/dolphinscheduler/server/master/runner/MasterSchedulerService.java | scheduleProcess();
} catch (Exception e) {
logger.error("master scheduler thread error", e);
}
}
}
/**
* 1. get command by slot
* 2. donot handle command if slot is empty
*/
private void scheduleProcess() throws Exception {
List<Command> commands = findCommands();
if (CollectionUtils.isEmpty(commands)) {
Thread.sleep(Constants.SLEEP_TIME_MILLIS);
return;
}
List<ProcessInstance> processInstances = command2ProcessInstance(commands);
if (CollectionUtils.isEmpty(processInstances)) {
return;
}
for (ProcessInstance processInstance : processInstances) {
if (processInstance == null) {
continue;
}
WorkflowExecuteThread workflowExecuteThread = new WorkflowExecuteThread(
processInstance
, processService
, nettyExecutorManager
, processAlertManager |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-master/src/main/java/org/apache/dolphinscheduler/server/master/runner/MasterSchedulerService.java | , masterConfig
, stateWheelExecuteThread);
this.processInstanceExecCacheManager.cache(processInstance.getId(), workflowExecuteThread);
if (processInstance.getTimeout() > 0) {
stateWheelExecuteThread.addProcess4TimeoutCheck(processInstance);
}
workflowExecuteThreadPool.startWorkflow(workflowExecuteThread);
}
}
private List<ProcessInstance> command2ProcessInstance(List<Command> commands) {
List<ProcessInstance> processInstances = Collections.synchronizedList(new ArrayList<>(commands.size()));
CountDownLatch latch = new CountDownLatch(commands.size());
for (final Command command : commands) {
masterPrepareExecService.execute(() -> {
try {
SlotCheckState slotCheckState = slotCheck(command);
if (slotCheckState.equals(SlotCheckState.CHANGE) || slotCheckState.equals(SlotCheckState.INJECT)) {
logger.info("handle command {} skip, slot check state: {}", command.getId(), slotCheckState);
return;
}
ProcessInstance processInstance = processService.handleCommand(logger,
getLocalAddress(),
command);
if (processInstance != null) {
processInstances.add(processInstance);
logger.info("handle command {} end, create process instance {}", command.getId(), processInstance.getId());
}
} catch (Exception e) {
logger.error("handle command error ", e); |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-master/src/main/java/org/apache/dolphinscheduler/server/master/runner/MasterSchedulerService.java | processService.moveToErrorCommand(command, e.toString());
} finally {
latch.countDown();
}
});
}
try {
latch.await();
} catch (InterruptedException e) {
logger.error("countDownLatch await error ", e);
}
return processInstances;
}
private List<Command> findCommands() {
int pageNumber = 0;
int pageSize = masterConfig.getFetchCommandNum();
List<Command> result = new ArrayList<>();
while (Stopper.isRunning()) {
List<Command> commandList = processService.findCommandPage(pageSize, pageNumber);
if (commandList.size() == 0) {
return result;
}
for (Command command : commandList) {
SlotCheckState slotCheckState = slotCheck(command);
if (slotCheckState.equals(SlotCheckState.CHANGE)) {
return new ArrayList<>();
} |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-master/src/main/java/org/apache/dolphinscheduler/server/master/runner/MasterSchedulerService.java | if (slotCheckState.equals(SlotCheckState.PASS)) {
result.add(command);
}
}
if (CollectionUtils.isNotEmpty(result)) {
logger.info("find {} commands, slot:{}", result.size(), ServerNodeManager.getSlot());
break;
}
pageNumber += 1;
}
return result;
}
private SlotCheckState slotCheck(Command command) {
int slot = ServerNodeManager.getSlot();
int masterSize = ServerNodeManager.getMasterSize();
SlotCheckState state;
if (masterSize <= 0) {
state = SlotCheckState.CHANGE;
} else if (command.getId() % masterSize == slot) {
state = SlotCheckState.PASS;
} else {
state = SlotCheckState.INJECT;
}
return state;
}
private String getLocalAddress() {
return NetUtils.getAddr(masterConfig.getListenPort());
}
} |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | /*
* 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
* |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | * 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.dolphinscheduler.service.process;
import static org.apache.dolphinscheduler.common.Constants.CMDPARAM_COMPLEMENT_DATA_END_DATE;
import static org.apache.dolphinscheduler.common.Constants.CMDPARAM_COMPLEMENT_DATA_START_DATE;
import static org.apache.dolphinscheduler.common.Constants.CMD_PARAM_EMPTY_SUB_PROCESS;
import static org.apache.dolphinscheduler.common.Constants.CMD_PARAM_FATHER_PARAMS;
import static org.apache.dolphinscheduler.common.Constants.CMD_PARAM_RECOVER_PROCESS_ID_STRING;
import static org.apache.dolphinscheduler.common.Constants.CMD_PARAM_SUB_PROCESS;
import static org.apache.dolphinscheduler.common.Constants.CMD_PARAM_SUB_PROCESS_DEFINE_CODE;
import static org.apache.dolphinscheduler.common.Constants.CMD_PARAM_SUB_PROCESS_PARENT_INSTANCE_ID;
import static org.apache.dolphinscheduler.common.Constants.LOCAL_PARAMS;
import static org.apache.dolphinscheduler.plugin.task.api.utils.DataQualityConstants.TASK_INSTANCE_ID;
import static java.util.stream.Collectors.toSet;
import org.apache.dolphinscheduler.common.Constants;
import org.apache.dolphinscheduler.common.enums.AuthorizationType;
import org.apache.dolphinscheduler.common.enums.CommandType;
import org.apache.dolphinscheduler.common.enums.FailureStrategy;
import org.apache.dolphinscheduler.common.enums.Flag;
import org.apache.dolphinscheduler.common.enums.ReleaseState;
import org.apache.dolphinscheduler.common.enums.TaskDependType;
import org.apache.dolphinscheduler.common.enums.TaskGroupQueueStatus;
import org.apache.dolphinscheduler.common.enums.TimeoutFlag;
import org.apache.dolphinscheduler.common.enums.WarningType;
import org.apache.dolphinscheduler.common.graph.DAG;
import org.apache.dolphinscheduler.common.model.TaskNode; |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | import org.apache.dolphinscheduler.common.model.TaskNodeRelation;
import org.apache.dolphinscheduler.common.process.ProcessDag;
import org.apache.dolphinscheduler.common.utils.CodeGenerateUtils;
import org.apache.dolphinscheduler.common.utils.CodeGenerateUtils.CodeGenerateException;
import org.apache.dolphinscheduler.common.utils.DateUtils;
import org.apache.dolphinscheduler.common.utils.JSONUtils;
import org.apache.dolphinscheduler.common.utils.ParameterUtils;
import org.apache.dolphinscheduler.dao.entity.Command;
import org.apache.dolphinscheduler.dao.entity.DagData;
import org.apache.dolphinscheduler.dao.entity.DataSource;
import org.apache.dolphinscheduler.dao.entity.DependentProcessDefinition;
import org.apache.dolphinscheduler.dao.entity.DqComparisonType;
import org.apache.dolphinscheduler.dao.entity.DqExecuteResult;
import org.apache.dolphinscheduler.dao.entity.DqRule;
import org.apache.dolphinscheduler.dao.entity.DqRuleExecuteSql;
import org.apache.dolphinscheduler.dao.entity.DqRuleInputEntry;
import org.apache.dolphinscheduler.dao.entity.DqTaskStatisticsValue;
import org.apache.dolphinscheduler.dao.entity.Environment;
import org.apache.dolphinscheduler.dao.entity.ErrorCommand;
import org.apache.dolphinscheduler.dao.entity.ProcessDefinition;
import org.apache.dolphinscheduler.dao.entity.ProcessDefinitionLog;
import org.apache.dolphinscheduler.dao.entity.ProcessInstance;
import org.apache.dolphinscheduler.dao.entity.ProcessInstanceMap;
import org.apache.dolphinscheduler.dao.entity.ProcessTaskRelation;
import org.apache.dolphinscheduler.dao.entity.ProcessTaskRelationLog;
import org.apache.dolphinscheduler.dao.entity.Project;
import org.apache.dolphinscheduler.dao.entity.ProjectUser;
import org.apache.dolphinscheduler.dao.entity.Resource;
import org.apache.dolphinscheduler.dao.entity.Schedule;
import org.apache.dolphinscheduler.dao.entity.TaskDefinition; |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | import org.apache.dolphinscheduler.dao.entity.TaskDefinitionLog;
import org.apache.dolphinscheduler.dao.entity.TaskGroup;
import org.apache.dolphinscheduler.dao.entity.TaskGroupQueue;
import org.apache.dolphinscheduler.dao.entity.TaskInstance;
import org.apache.dolphinscheduler.dao.entity.Tenant;
import org.apache.dolphinscheduler.dao.entity.UdfFunc;
import org.apache.dolphinscheduler.dao.entity.User;
import org.apache.dolphinscheduler.dao.mapper.CommandMapper;
import org.apache.dolphinscheduler.dao.mapper.DataSourceMapper;
import org.apache.dolphinscheduler.dao.mapper.DqComparisonTypeMapper;
import org.apache.dolphinscheduler.dao.mapper.DqExecuteResultMapper;
import org.apache.dolphinscheduler.dao.mapper.DqRuleExecuteSqlMapper;
import org.apache.dolphinscheduler.dao.mapper.DqRuleInputEntryMapper;
import org.apache.dolphinscheduler.dao.mapper.DqRuleMapper;
import org.apache.dolphinscheduler.dao.mapper.DqTaskStatisticsValueMapper;
import org.apache.dolphinscheduler.dao.mapper.EnvironmentMapper;
import org.apache.dolphinscheduler.dao.mapper.ErrorCommandMapper;
import org.apache.dolphinscheduler.dao.mapper.ProcessDefinitionLogMapper;
import org.apache.dolphinscheduler.dao.mapper.ProcessDefinitionMapper;
import org.apache.dolphinscheduler.dao.mapper.ProcessInstanceMapMapper;
import org.apache.dolphinscheduler.dao.mapper.ProcessInstanceMapper;
import org.apache.dolphinscheduler.dao.mapper.ProcessTaskRelationLogMapper;
import org.apache.dolphinscheduler.dao.mapper.ProcessTaskRelationMapper;
import org.apache.dolphinscheduler.dao.mapper.ProjectMapper;
import org.apache.dolphinscheduler.dao.mapper.ResourceMapper;
import org.apache.dolphinscheduler.dao.mapper.ResourceUserMapper;
import org.apache.dolphinscheduler.dao.mapper.ScheduleMapper;
import org.apache.dolphinscheduler.dao.mapper.TaskDefinitionLogMapper;
import org.apache.dolphinscheduler.dao.mapper.TaskDefinitionMapper;
import org.apache.dolphinscheduler.dao.mapper.TaskGroupMapper; |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | import org.apache.dolphinscheduler.dao.mapper.TaskGroupQueueMapper;
import org.apache.dolphinscheduler.dao.mapper.TaskInstanceMapper;
import org.apache.dolphinscheduler.dao.mapper.TenantMapper;
import org.apache.dolphinscheduler.dao.mapper.UdfFuncMapper;
import org.apache.dolphinscheduler.dao.mapper.UserMapper;
import org.apache.dolphinscheduler.dao.mapper.WorkFlowLineageMapper;
import org.apache.dolphinscheduler.dao.utils.DagHelper;
import org.apache.dolphinscheduler.dao.utils.DqRuleUtils;
import org.apache.dolphinscheduler.plugin.task.api.enums.Direct;
import org.apache.dolphinscheduler.plugin.task.api.enums.ExecutionStatus;
import org.apache.dolphinscheduler.plugin.task.api.enums.dp.DqTaskState;
import org.apache.dolphinscheduler.plugin.task.api.model.DateInterval;
import org.apache.dolphinscheduler.plugin.task.api.model.Property;
import org.apache.dolphinscheduler.plugin.task.api.model.ResourceInfo;
import org.apache.dolphinscheduler.plugin.task.api.parameters.AbstractParameters;
import org.apache.dolphinscheduler.plugin.task.api.parameters.ParametersNode;
import org.apache.dolphinscheduler.plugin.task.api.parameters.SubProcessParameters;
import org.apache.dolphinscheduler.plugin.task.api.parameters.TaskTimeoutParameter;
import org.apache.dolphinscheduler.remote.command.StateEventChangeCommand;
import org.apache.dolphinscheduler.remote.command.TaskEventChangeCommand;
import org.apache.dolphinscheduler.remote.processor.StateEventCallbackService;
import org.apache.dolphinscheduler.remote.utils.Host;
import org.apache.dolphinscheduler.service.bean.SpringApplicationContext;
import org.apache.dolphinscheduler.service.exceptions.ServiceException;
import org.apache.dolphinscheduler.service.log.LogClientService;
import org.apache.dolphinscheduler.service.quartz.cron.CronUtils;
import org.apache.dolphinscheduler.service.task.TaskPluginManager;
import org.apache.dolphinscheduler.spi.enums.ResourceType;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang.StringUtils; |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.EnumMap;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Collectors;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.google.common.collect.Lists;
/**
* process relative dao that some mappers in this.
*/
@Component
public class ProcessService {
private final Logger logger = LoggerFactory.getLogger(getClass());
private final int[] stateArray = new int[]{ExecutionStatus.SUBMITTED_SUCCESS.ordinal(),
ExecutionStatus.RUNNING_EXECUTION.ordinal(),
ExecutionStatus.DELAY_EXECUTION.ordinal(), |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | ExecutionStatus.READY_PAUSE.ordinal(),
ExecutionStatus.READY_STOP.ordinal()};
@Autowired
private UserMapper userMapper;
@Autowired
private ProcessDefinitionMapper processDefineMapper;
@Autowired
private ProcessDefinitionLogMapper processDefineLogMapper;
@Autowired
private ProcessInstanceMapper processInstanceMapper;
@Autowired
private DataSourceMapper dataSourceMapper;
@Autowired
private ProcessInstanceMapMapper processInstanceMapMapper;
@Autowired
private TaskInstanceMapper taskInstanceMapper;
@Autowired
private CommandMapper commandMapper;
@Autowired
private ScheduleMapper scheduleMapper;
@Autowired
private UdfFuncMapper udfFuncMapper;
@Autowired
private ResourceMapper resourceMapper;
@Autowired
private ResourceUserMapper resourceUserMapper;
@Autowired
private ErrorCommandMapper errorCommandMapper;
@Autowired
private TenantMapper tenantMapper; |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | @Autowired
private ProjectMapper projectMapper;
@Autowired
private DqExecuteResultMapper dqExecuteResultMapper;
@Autowired
private DqRuleMapper dqRuleMapper;
@Autowired
private DqRuleInputEntryMapper dqRuleInputEntryMapper;
@Autowired
private DqRuleExecuteSqlMapper dqRuleExecuteSqlMapper;
@Autowired
private DqComparisonTypeMapper dqComparisonTypeMapper;
@Autowired
private DqTaskStatisticsValueMapper dqTaskStatisticsValueMapper;
@Autowired
private TaskDefinitionMapper taskDefinitionMapper;
@Autowired
private TaskDefinitionLogMapper taskDefinitionLogMapper;
@Autowired
private ProcessTaskRelationMapper processTaskRelationMapper;
@Autowired
private ProcessTaskRelationLogMapper processTaskRelationLogMapper;
@Autowired
StateEventCallbackService stateEventCallbackService;
@Autowired
private EnvironmentMapper environmentMapper;
@Autowired
private TaskGroupQueueMapper taskGroupQueueMapper;
@Autowired
private TaskGroupMapper taskGroupMapper; |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | @Autowired
private WorkFlowLineageMapper workFlowLineageMapper;
@Autowired
private TaskPluginManager taskPluginManager;
/**
* handle Command (construct ProcessInstance from Command) , wrapped in transaction
*
* @param logger logger
* @param host host
* @param command found command
* @return process instance
*/
@Transactional
public ProcessInstance handleCommand(Logger logger, String host, Command command) {
ProcessInstance processInstance = constructProcessInstance(command, host);
if (processInstance == null) {
logger.error("scan command, command parameter is error: {}", command);
moveToErrorCommand(command, "process instance is null");
return null;
}
processInstance.setCommandType(command.getCommandType());
processInstance.addHistoryCmd(command.getCommandType());
ProcessDefinition processDefinition = this.findProcessDefinition(processInstance.getProcessDefinitionCode(), processInstance.getProcessDefinitionVersion());
if (processDefinition.getExecutionType().typeIsSerial()) {
saveSerialProcess(processInstance, processDefinition);
if (processInstance.getState() != ExecutionStatus.SUBMITTED_SUCCESS) {
setSubProcessParam(processInstance);
deleteCommandWithCheck(command.getId()); |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | return null;
}
} else {
saveProcessInstance(processInstance);
}
setSubProcessParam(processInstance);
deleteCommandWithCheck(command.getId());
return processInstance;
}
protected void saveSerialProcess(ProcessInstance processInstance, ProcessDefinition processDefinition) {
processInstance.setState(ExecutionStatus.SERIAL_WAIT);
saveProcessInstance(processInstance);
if (processDefinition.getExecutionType().typeIsSerialWait()) {
while (true) {
List<ProcessInstance> runningProcessInstances = this.processInstanceMapper.queryByProcessDefineCodeAndStatusAndNextId(processInstance.getProcessDefinitionCode(),
Constants.RUNNING_PROCESS_STATE, processInstance.getId());
if (CollectionUtils.isEmpty(runningProcessInstances)) {
processInstance.setState(ExecutionStatus.SUBMITTED_SUCCESS);
saveProcessInstance(processInstance);
return;
}
ProcessInstance runningProcess = runningProcessInstances.get(0);
if (this.processInstanceMapper.updateNextProcessIdById(processInstance.getId(), runningProcess.getId())) {
return;
}
}
} else if (processDefinition.getExecutionType().typeIsSerialDiscard()) {
List<ProcessInstance> runningProcessInstances = this.processInstanceMapper.queryByProcessDefineCodeAndStatusAndNextId(processInstance.getProcessDefinitionCode(), |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | Constants.RUNNING_PROCESS_STATE, processInstance.getId());
if (CollectionUtils.isEmpty(runningProcessInstances)) {
processInstance.setState(ExecutionStatus.STOP);
saveProcessInstance(processInstance);
}
} else if (processDefinition.getExecutionType().typeIsSerialPriority()) {
List<ProcessInstance> runningProcessInstances = this.processInstanceMapper.queryByProcessDefineCodeAndStatusAndNextId(processInstance.getProcessDefinitionCode(),
Constants.RUNNING_PROCESS_STATE, processInstance.getId());
if (CollectionUtils.isNotEmpty(runningProcessInstances)) {
for (ProcessInstance info : runningProcessInstances) {
info.setCommandType(CommandType.STOP);
info.addHistoryCmd(CommandType.STOP);
info.setState(ExecutionStatus.READY_STOP);
int update = updateProcessInstance(info);
if (update > 0) {
String host = info.getHost();
String address = host.split(":")[0];
int port = Integer.parseInt(host.split(":")[1]);
StateEventChangeCommand stateEventChangeCommand = new StateEventChangeCommand(
info.getId(), 0, info.getState(), info.getId(), 0
);
try {
stateEventCallbackService.sendResult(address, port, stateEventChangeCommand.convert2Command());
} catch (Exception e) {
logger.error("sendResultError");
}
}
}
} |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | }
}
/**
* save error command, and delete original command
*
* @param command command
* @param message message
*/
public void moveToErrorCommand(Command command, String message) {
ErrorCommand errorCommand = new ErrorCommand(command, message);
this.errorCommandMapper.insert(errorCommand);
this.commandMapper.deleteById(command.getId());
}
/**
* set process waiting thread
*
* @param command command
* @param processInstance processInstance
* @return process instance
*/
private ProcessInstance setWaitingThreadProcess(Command command, ProcessInstance processInstance) {
processInstance.setState(ExecutionStatus.WAITING_THREAD);
if (command.getCommandType() != CommandType.RECOVER_WAITING_THREAD) {
processInstance.addHistoryCmd(command.getCommandType());
}
saveProcessInstance(processInstance);
this.setSubProcessParam(processInstance);
createRecoveryWaitingThreadCommand(command, processInstance);
return null;
} |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | /**
* insert one command
*
* @param command command
* @return create result
*/
public int createCommand(Command command) {
int result = 0;
if (command != null) {
result = commandMapper.insert(command);
}
return result;
}
/**
* get command page
*/
public List<Command> findCommandPage(int pageSize, int pageNumber) {
return commandMapper.queryCommandPage(pageSize, pageNumber * pageSize);
}
/**
* check the input command exists in queue list
*
* @param command command
* @return create command result
*/
public boolean verifyIsNeedCreateCommand(Command command) {
boolean isNeedCreate = true;
EnumMap<CommandType, Integer> cmdTypeMap = new EnumMap<>(CommandType.class);
cmdTypeMap.put(CommandType.REPEAT_RUNNING, 1);
cmdTypeMap.put(CommandType.RECOVER_SUSPENDED_PROCESS, 1); |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | cmdTypeMap.put(CommandType.START_FAILURE_TASK_PROCESS, 1);
CommandType commandType = command.getCommandType();
if (cmdTypeMap.containsKey(commandType)) {
ObjectNode cmdParamObj = JSONUtils.parseObject(command.getCommandParam());
int processInstanceId = cmdParamObj.path(CMD_PARAM_RECOVER_PROCESS_ID_STRING).asInt();
List<Command> commands = commandMapper.selectList(null);
for (Command tmpCommand : commands) {
if (cmdTypeMap.containsKey(tmpCommand.getCommandType())) {
ObjectNode tempObj = JSONUtils.parseObject(tmpCommand.getCommandParam());
if (tempObj != null && processInstanceId == tempObj.path(CMD_PARAM_RECOVER_PROCESS_ID_STRING).asInt()) {
isNeedCreate = false;
break;
}
}
}
}
return isNeedCreate;
}
/**
* find process instance detail by id
*
* @param processId processId
* @return process instance
*/
public ProcessInstance findProcessInstanceDetailById(int processId) {
return processInstanceMapper.queryDetailById(processId);
}
/**
* get task node list by definitionId |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | */
public List<TaskDefinition> getTaskNodeListByDefinition(long defineCode) {
ProcessDefinition processDefinition = processDefineMapper.queryByCode(defineCode);
if (processDefinition == null) {
logger.error("process define not exists");
return Lists.newArrayList();
}
List<ProcessTaskRelationLog> processTaskRelations = processTaskRelationLogMapper.queryByProcessCodeAndVersion(processDefinition.getCode(), processDefinition.getVersion());
Set<TaskDefinition> taskDefinitionSet = new HashSet<>();
for (ProcessTaskRelationLog processTaskRelation : processTaskRelations) {
if (processTaskRelation.getPostTaskCode() > 0) {
taskDefinitionSet.add(new TaskDefinition(processTaskRelation.getPostTaskCode(), processTaskRelation.getPostTaskVersion()));
}
}
if (taskDefinitionSet.isEmpty()) {
return Lists.newArrayList();
}
List<TaskDefinitionLog> taskDefinitionLogs = taskDefinitionLogMapper.queryByTaskDefinitions(taskDefinitionSet);
return Lists.newArrayList(taskDefinitionLogs);
}
/**
* find process instance by id
*
* @param processId processId
* @return process instance
*/
public ProcessInstance findProcessInstanceById(int processId) {
return processInstanceMapper.selectById(processId);
}
/** |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | * find process define by id.
*
* @param processDefinitionId processDefinitionId
* @return process definition
*/
public ProcessDefinition findProcessDefineById(int processDefinitionId) {
return processDefineMapper.selectById(processDefinitionId);
}
/**
* find process define by code and version.
*
* @param processDefinitionCode processDefinitionCode
* @return process definition
*/
public ProcessDefinition findProcessDefinition(Long processDefinitionCode, int version) {
ProcessDefinition processDefinition = processDefineMapper.queryByCode(processDefinitionCode);
if (processDefinition == null || processDefinition.getVersion() != version) {
processDefinition = processDefineLogMapper.queryByDefinitionCodeAndVersion(processDefinitionCode, version);
if (processDefinition != null) {
processDefinition.setId(0);
}
}
return processDefinition;
}
/**
* find process define by code.
*
* @param processDefinitionCode processDefinitionCode
* @return process definition
*/ |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | public ProcessDefinition findProcessDefinitionByCode(Long processDefinitionCode) {
return processDefineMapper.queryByCode(processDefinitionCode);
}
/**
* delete work process instance by id
*
* @param processInstanceId processInstanceId
* @return delete process instance result
*/
public int deleteWorkProcessInstanceById(int processInstanceId) {
return processInstanceMapper.deleteById(processInstanceId);
}
/**
* delete all sub process by parent instance id
*
* @param processInstanceId processInstanceId
* @return delete all sub process instance result
*/
public int deleteAllSubWorkProcessByParentId(int processInstanceId) {
List<Integer> subProcessIdList = processInstanceMapMapper.querySubIdListByParentId(processInstanceId);
for (Integer subId : subProcessIdList) {
deleteAllSubWorkProcessByParentId(subId);
deleteWorkProcessMapByParentId(subId);
removeTaskLogFile(subId);
deleteWorkProcessInstanceById(subId);
}
return 1;
}
/**
* remove task log file |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | *
* @param processInstanceId processInstanceId
*/
public void removeTaskLogFile(Integer processInstanceId) {
List<TaskInstance> taskInstanceList = findValidTaskListByProcessId(processInstanceId);
if (CollectionUtils.isEmpty(taskInstanceList)) {
return;
}
try (LogClientService logClient = new LogClientService()) {
for (TaskInstance taskInstance : taskInstanceList) {
String taskLogPath = taskInstance.getLogPath();
if (StringUtils.isEmpty(taskInstance.getHost())) {
continue;
}
Host host = Host.of(taskInstance.getHost());
logClient.removeTaskLog(host.getIp(), host.getPort(), taskLogPath);
}
}
}
/**
* recursive delete all task instance by process instance id
* @param processInstanceId
*/
public void deleteWorkTaskInstanceByProcessInstanceId(int processInstanceId) {
List<TaskInstance> taskInstanceList = findValidTaskListByProcessId(processInstanceId);
if (CollectionUtils.isEmpty(taskInstanceList)) {
return;
}
List<Integer> taskInstanceIdList = new ArrayList<>(); |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | for (TaskInstance taskInstance : taskInstanceList) {
taskInstanceIdList.add(taskInstance.getId());
}
taskInstanceMapper.deleteBatchIds(taskInstanceIdList);
}
/**
* recursive query sub process definition id by parent id.
*
* @param parentCode parentCode
* @param ids ids
*/
public void recurseFindSubProcess(long parentCode, List<Long> ids) {
List<TaskDefinition> taskNodeList = this.getTaskNodeListByDefinition(parentCode);
if (taskNodeList != null && !taskNodeList.isEmpty()) {
for (TaskDefinition taskNode : taskNodeList) {
String parameter = taskNode.getTaskParams();
ObjectNode parameterJson = JSONUtils.parseObject(parameter);
if (parameterJson.get(CMD_PARAM_SUB_PROCESS_DEFINE_CODE) != null) {
SubProcessParameters subProcessParam = JSONUtils.parseObject(parameter, SubProcessParameters.class);
ids.add(subProcessParam.getProcessDefinitionCode());
recurseFindSubProcess(subProcessParam.getProcessDefinitionCode(), ids);
}
}
}
}
/**
* create recovery waiting thread command when thread pool is not enough for the process instance.
* sub work process instance need not to create recovery command.
* create recovery waiting thread command and delete origin command at the same time.
* if the recovery command is exists, only update the field update_time |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | *
* @param originCommand originCommand
* @param processInstance processInstance
*/
public void createRecoveryWaitingThreadCommand(Command originCommand, ProcessInstance processInstance) {
if (processInstance.getIsSubProcess() == Flag.YES) {
if (originCommand != null) {
commandMapper.deleteById(originCommand.getId());
}
return;
}
Map<String, String> cmdParam = new HashMap<>();
cmdParam.put(Constants.CMD_PARAM_RECOVERY_WAITING_THREAD, String.valueOf(processInstance.getId()));
if (originCommand == null) {
Command command = new Command(
CommandType.RECOVER_WAITING_THREAD,
processInstance.getTaskDependType(),
processInstance.getFailureStrategy(),
processInstance.getExecutorId(),
processInstance.getProcessDefinition().getCode(),
JSONUtils.toJsonString(cmdParam),
processInstance.getWarningType(),
processInstance.getWarningGroupId(),
processInstance.getScheduleTime(),
processInstance.getWorkerGroup(),
processInstance.getEnvironmentCode(),
processInstance.getProcessInstancePriority(),
processInstance.getDryRun(), |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | processInstance.getId(),
processInstance.getProcessDefinitionVersion()
);
saveCommand(command);
return;
}
if (originCommand.getCommandType() == CommandType.RECOVER_WAITING_THREAD) {
originCommand.setUpdateTime(new Date());
saveCommand(originCommand);
} else {
commandMapper.deleteById(originCommand.getId());
originCommand.setId(0);
originCommand.setCommandType(CommandType.RECOVER_WAITING_THREAD);
originCommand.setUpdateTime(new Date());
originCommand.setCommandParam(JSONUtils.toJsonString(cmdParam));
originCommand.setProcessInstancePriority(processInstance.getProcessInstancePriority());
saveCommand(originCommand);
}
}
/**
* get schedule time from command
*
* @param command command
* @param cmdParam cmdParam map
* @return date
*/
private Date getScheduleTime(Command command, Map<String, String> cmdParam) {
Date scheduleTime = command.getScheduleTime(); |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | if (scheduleTime == null
&& cmdParam != null
&& cmdParam.containsKey(CMDPARAM_COMPLEMENT_DATA_START_DATE)) {
Date start = DateUtils.stringToDate(cmdParam.get(CMDPARAM_COMPLEMENT_DATA_START_DATE));
Date end = DateUtils.stringToDate(cmdParam.get(CMDPARAM_COMPLEMENT_DATA_END_DATE));
List<Schedule> schedules = queryReleaseSchedulerListByProcessDefinitionCode(command.getProcessDefinitionCode());
List<Date> complementDateList = CronUtils.getSelfFireDateList(start, end, schedules);
if (complementDateList.size() > 0) {
scheduleTime = complementDateList.get(0);
} else {
logger.error("set scheduler time error: complement date list is empty, command: {}",
command.toString());
}
}
return scheduleTime;
}
/**
* generate a new work process instance from command.
*
* @param processDefinition processDefinition
* @param command command
* @param cmdParam cmdParam map
* @return process instance
*/
private ProcessInstance generateNewProcessInstance(ProcessDefinition processDefinition,
Command command,
Map<String, String> cmdParam) {
ProcessInstance processInstance = new ProcessInstance(processDefinition);
processInstance.setProcessDefinitionCode(processDefinition.getCode());
processInstance.setProcessDefinitionVersion(processDefinition.getVersion()); |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | processInstance.setState(ExecutionStatus.RUNNING_EXECUTION);
processInstance.setRecovery(Flag.NO);
processInstance.setStartTime(new Date());
processInstance.setRestartTime(processInstance.getStartTime());
processInstance.setRunTimes(1);
processInstance.setMaxTryTimes(0);
processInstance.setCommandParam(command.getCommandParam());
processInstance.setCommandType(command.getCommandType());
processInstance.setIsSubProcess(Flag.NO);
processInstance.setTaskDependType(command.getTaskDependType());
processInstance.setFailureStrategy(command.getFailureStrategy());
processInstance.setExecutorId(command.getExecutorId());
WarningType warningType = command.getWarningType() == null ? WarningType.NONE : command.getWarningType();
processInstance.setWarningType(warningType);
Integer warningGroupId = command.getWarningGroupId() == null ? 0 : command.getWarningGroupId();
processInstance.setWarningGroupId(warningGroupId);
processInstance.setDryRun(command.getDryRun());
if (command.getScheduleTime() != null) {
processInstance.setScheduleTime(command.getScheduleTime());
}
processInstance.setCommandStartTime(command.getStartTime());
processInstance.setLocations(processDefinition.getLocations());
setGlobalParamIfCommanded(processDefinition, cmdParam);
processInstance.setGlobalParams(ParameterUtils.curingGlobalParams(
processDefinition.getGlobalParamMap(),
processDefinition.getGlobalParamList(),
getCommandTypeIfComplement(processInstance, command),
processInstance.getScheduleTime())); |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | processInstance.setProcessInstancePriority(command.getProcessInstancePriority());
String workerGroup = StringUtils.isBlank(command.getWorkerGroup()) ? Constants.DEFAULT_WORKER_GROUP : command.getWorkerGroup();
processInstance.setWorkerGroup(workerGroup);
processInstance.setEnvironmentCode(Objects.isNull(command.getEnvironmentCode()) ? -1 : command.getEnvironmentCode());
processInstance.setTimeout(processDefinition.getTimeout());
processInstance.setTenantId(processDefinition.getTenantId());
return processInstance;
}
private void setGlobalParamIfCommanded(ProcessDefinition processDefinition, Map<String, String> cmdParam) {
Map<String, String> startParamMap = new HashMap<>();
if (cmdParam != null && cmdParam.containsKey(Constants.CMD_PARAM_START_PARAMS)) {
String startParamJson = cmdParam.get(Constants.CMD_PARAM_START_PARAMS);
startParamMap = JSONUtils.toMap(startParamJson);
}
Map<String, String> fatherParamMap = new HashMap<>();
if (cmdParam != null && cmdParam.containsKey(Constants.CMD_PARAM_FATHER_PARAMS)) {
String fatherParamJson = cmdParam.get(Constants.CMD_PARAM_FATHER_PARAMS);
fatherParamMap = JSONUtils.toMap(fatherParamJson);
}
startParamMap.putAll(fatherParamMap);
if (startParamMap.size() > 0
&& processDefinition.getGlobalParamMap() != null) {
for (Map.Entry<String, String> param : processDefinition.getGlobalParamMap().entrySet()) {
String val = startParamMap.get(param.getKey());
if (val != null) {
param.setValue(val);
} |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | }
}
}
/**
* get process tenant
* there is tenant id in definition, use the tenant of the definition.
* if there is not tenant id in the definiton or the tenant not exist
* use definition creator's tenant.
*
* @param tenantId tenantId
* @param userId userId
* @return tenant
*/
public Tenant getTenantForProcess(int tenantId, int userId) {
Tenant tenant = null;
if (tenantId >= 0) {
tenant = tenantMapper.queryById(tenantId);
}
if (userId == 0) {
return null;
}
if (tenant == null) {
User user = userMapper.selectById(userId);
tenant = tenantMapper.queryById(user.getTenantId());
}
return tenant;
}
/**
* get an environment
* use the code of the environment to find a environment. |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | *
* @param environmentCode environmentCode
* @return Environment
*/
public Environment findEnvironmentByCode(Long environmentCode) {
Environment environment = null;
if (environmentCode >= 0) {
environment = environmentMapper.queryByEnvironmentCode(environmentCode);
}
return environment;
}
/**
* check command parameters is valid
*
* @param command command
* @param cmdParam cmdParam map
* @return whether command param is valid
*/
private Boolean checkCmdParam(Command command, Map<String, String> cmdParam) {
if (command.getTaskDependType() == TaskDependType.TASK_ONLY || command.getTaskDependType() == TaskDependType.TASK_PRE) {
if (cmdParam == null
|| !cmdParam.containsKey(Constants.CMD_PARAM_START_NODES)
|| cmdParam.get(Constants.CMD_PARAM_START_NODES).isEmpty()) {
logger.error("command node depend type is {}, but start nodes is null ", command.getTaskDependType());
return false;
}
}
return true;
}
/** |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | * construct process instance according to one command.
*
* @param command command
* @param host host
* @return process instance
*/
protected ProcessInstance constructProcessInstance(Command command, String host) {
ProcessInstance processInstance;
ProcessDefinition processDefinition;
CommandType commandType = command.getCommandType();
processDefinition = this.findProcessDefinition(command.getProcessDefinitionCode(), command.getProcessDefinitionVersion());
if (processDefinition == null) {
logger.error("cannot find the work process define! define code : {}", command.getProcessDefinitionCode());
return null;
}
Map<String, String> cmdParam = JSONUtils.toMap(command.getCommandParam());
int processInstanceId = command.getProcessInstanceId();
if (processInstanceId == 0) {
processInstance = generateNewProcessInstance(processDefinition, command, cmdParam);
} else {
processInstance = this.findProcessInstanceDetailById(processInstanceId);
if (processInstance == null) {
return processInstance;
}
}
if (cmdParam != null) {
CommandType commandTypeIfComplement = getCommandTypeIfComplement(processInstance, command);
if (commandTypeIfComplement == CommandType.REPEAT_RUNNING) {
setGlobalParamIfCommanded(processDefinition, cmdParam); |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | }
processInstance.setGlobalParams(ParameterUtils.curingGlobalParams(
processDefinition.getGlobalParamMap(),
processDefinition.getGlobalParamList(),
commandTypeIfComplement,
processInstance.getScheduleTime()));
processInstance.setProcessDefinition(processDefinition);
}
if (processInstance.getCommandParam() != null) {
Map<String, String> processCmdParam = JSONUtils.toMap(processInstance.getCommandParam());
processCmdParam.forEach((key, value) -> {
if (!cmdParam.containsKey(key)) {
cmdParam.put(key, value);
}
});
}
if (cmdParam != null && cmdParam.containsKey(Constants.CMD_PARAM_SUB_PROCESS)) {
processInstance.setCommandParam(command.getCommandParam());
}
if (Boolean.FALSE.equals(checkCmdParam(command, cmdParam))) {
logger.error("command parameter check failed!");
return null;
}
if (command.getScheduleTime() != null) {
processInstance.setScheduleTime(command.getScheduleTime());
}
processInstance.setHost(host); |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | processInstance.setRestartTime(new Date());
ExecutionStatus runStatus = ExecutionStatus.RUNNING_EXECUTION;
int runTime = processInstance.getRunTimes();
switch (commandType) {
case START_PROCESS:
break;
case START_FAILURE_TASK_PROCESS:
List<Integer> failedList = this.findTaskIdByInstanceState(processInstance.getId(), ExecutionStatus.FAILURE);
List<Integer> toleranceList = this.findTaskIdByInstanceState(processInstance.getId(), ExecutionStatus.NEED_FAULT_TOLERANCE);
List<Integer> killedList = this.findTaskIdByInstanceState(processInstance.getId(), ExecutionStatus.KILL);
cmdParam.remove(Constants.CMD_PARAM_RECOVERY_START_NODE_STRING);
failedList.addAll(killedList);
failedList.addAll(toleranceList);
for (Integer taskId : failedList) {
initTaskInstance(this.findTaskInstanceById(taskId));
}
cmdParam.put(Constants.CMD_PARAM_RECOVERY_START_NODE_STRING,
String.join(Constants.COMMA, convertIntListToString(failedList)));
processInstance.setCommandParam(JSONUtils.toJsonString(cmdParam));
processInstance.setRunTimes(runTime + 1);
break;
case START_CURRENT_TASK_PROCESS:
break;
case RECOVER_WAITING_THREAD:
break;
case RECOVER_SUSPENDED_PROCESS:
cmdParam.remove(Constants.CMD_PARAM_RECOVERY_START_NODE_STRING);
List<Integer> suspendedNodeList = this.findTaskIdByInstanceState(processInstance.getId(), ExecutionStatus.PAUSE); |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | List<Integer> stopNodeList = findTaskIdByInstanceState(processInstance.getId(),
ExecutionStatus.KILL);
suspendedNodeList.addAll(stopNodeList);
for (Integer taskId : suspendedNodeList) {
initTaskInstance(this.findTaskInstanceById(taskId));
}
cmdParam.put(Constants.CMD_PARAM_RECOVERY_START_NODE_STRING, String.join(",", convertIntListToString(suspendedNodeList)));
processInstance.setCommandParam(JSONUtils.toJsonString(cmdParam));
processInstance.setRunTimes(runTime + 1);
break;
case RECOVER_TOLERANCE_FAULT_PROCESS:
processInstance.setRecovery(Flag.YES);
runStatus = processInstance.getState();
break;
case COMPLEMENT_DATA:
if (processInstance.getId() != 0) {
List<TaskInstance> taskInstanceList = this.findValidTaskListByProcessId(processInstance.getId());
for (TaskInstance taskInstance : taskInstanceList) {
taskInstance.setFlag(Flag.NO);
this.updateTaskInstance(taskInstance);
}
}
break;
case REPEAT_RUNNING:
if (cmdParam.containsKey(Constants.CMD_PARAM_RECOVERY_START_NODE_STRING)) {
cmdParam.remove(Constants.CMD_PARAM_RECOVERY_START_NODE_STRING); |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | processInstance.setCommandParam(JSONUtils.toJsonString(cmdParam));
}
List<TaskInstance> validTaskList = findValidTaskListByProcessId(processInstance.getId());
for (TaskInstance taskInstance : validTaskList) {
taskInstance.setFlag(Flag.NO);
updateTaskInstance(taskInstance);
}
processInstance.setStartTime(new Date());
processInstance.setRestartTime(processInstance.getStartTime());
processInstance.setEndTime(null);
processInstance.setRunTimes(runTime + 1);
initComplementDataParam(processDefinition, processInstance, cmdParam);
break;
case SCHEDULER:
break;
default:
break;
}
processInstance.setState(runStatus);
return processInstance;
}
/**
* get process definition by command
* If it is a fault-tolerant command, get the specified version of ProcessDefinition through ProcessInstance
* Otherwise, get the latest version of ProcessDefinition
*
* @return ProcessDefinition
*/
private ProcessDefinition getProcessDefinitionByCommand(long processDefinitionCode, Map<String, String> cmdParam) { |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | if (cmdParam != null) {
int processInstanceId = 0;
if (cmdParam.containsKey(Constants.CMD_PARAM_RECOVER_PROCESS_ID_STRING)) {
processInstanceId = Integer.parseInt(cmdParam.get(Constants.CMD_PARAM_RECOVER_PROCESS_ID_STRING));
} else if (cmdParam.containsKey(Constants.CMD_PARAM_SUB_PROCESS)) {
processInstanceId = Integer.parseInt(cmdParam.get(Constants.CMD_PARAM_SUB_PROCESS));
} else if (cmdParam.containsKey(Constants.CMD_PARAM_RECOVERY_WAITING_THREAD)) {
processInstanceId = Integer.parseInt(cmdParam.get(Constants.CMD_PARAM_RECOVERY_WAITING_THREAD));
}
if (processInstanceId != 0) {
ProcessInstance processInstance = this.findProcessInstanceDetailById(processInstanceId);
if (processInstance == null) {
return null;
}
return processDefineLogMapper.queryByDefinitionCodeAndVersion(
processInstance.getProcessDefinitionCode(), processInstance.getProcessDefinitionVersion());
}
}
return processDefineMapper.queryByCode(processDefinitionCode);
}
/**
* return complement data if the process start with complement data
*
* @param processInstance processInstance
* @param command command
* @return command type
*/
private CommandType getCommandTypeIfComplement(ProcessInstance processInstance, Command command) {
if (CommandType.COMPLEMENT_DATA == processInstance.getCmdTypeIfComplement()) {
return CommandType.COMPLEMENT_DATA; |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | } else {
return command.getCommandType();
}
}
/**
* initialize complement data parameters
*
* @param processDefinition processDefinition
* @param processInstance processInstance
* @param cmdParam cmdParam
*/
private void initComplementDataParam(ProcessDefinition processDefinition,
ProcessInstance processInstance,
Map<String, String> cmdParam) {
if (!processInstance.isComplementData()) {
return;
}
Date start = DateUtils.stringToDate(cmdParam.get(CMDPARAM_COMPLEMENT_DATA_START_DATE));
Date end = DateUtils.stringToDate(cmdParam.get(CMDPARAM_COMPLEMENT_DATA_END_DATE));
List<Schedule> listSchedules = queryReleaseSchedulerListByProcessDefinitionCode(processInstance.getProcessDefinitionCode());
List<Date> complementDate = CronUtils.getSelfFireDateList(start, end, listSchedules);
if (complementDate.size() > 0
&& Flag.NO == processInstance.getIsSubProcess()) {
processInstance.setScheduleTime(complementDate.get(0));
}
processInstance.setGlobalParams(ParameterUtils.curingGlobalParams(
processDefinition.getGlobalParamMap(),
processDefinition.getGlobalParamList(),
CommandType.COMPLEMENT_DATA, processInstance.getScheduleTime()));
} |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | /**
* set sub work process parameters.
* handle sub work process instance, update relation table and command parameters
* set sub work process flag, extends parent work process command parameters
*
* @param subProcessInstance subProcessInstance
*/
public void setSubProcessParam(ProcessInstance subProcessInstance) {
String cmdParam = subProcessInstance.getCommandParam();
if (StringUtils.isEmpty(cmdParam)) {
return;
}
Map<String, String> paramMap = JSONUtils.toMap(cmdParam);
if (paramMap.containsKey(CMD_PARAM_SUB_PROCESS)
&& CMD_PARAM_EMPTY_SUB_PROCESS.equals(paramMap.get(CMD_PARAM_SUB_PROCESS))) {
paramMap.remove(CMD_PARAM_SUB_PROCESS);
paramMap.put(CMD_PARAM_SUB_PROCESS, String.valueOf(subProcessInstance.getId()));
subProcessInstance.setCommandParam(JSONUtils.toJsonString(paramMap));
subProcessInstance.setIsSubProcess(Flag.YES);
this.saveProcessInstance(subProcessInstance);
}
String parentInstanceId = paramMap.get(CMD_PARAM_SUB_PROCESS_PARENT_INSTANCE_ID);
if (StringUtils.isNotEmpty(parentInstanceId)) {
ProcessInstance parentInstance = findProcessInstanceDetailById(Integer.parseInt(parentInstanceId));
if (parentInstance != null) {
subProcessInstance.setGlobalParams(
joinGlobalParams(parentInstance.getGlobalParams(), subProcessInstance.getGlobalParams()));
this.saveProcessInstance(subProcessInstance); |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | } else {
logger.error("sub process command params error, cannot find parent instance: {} ", cmdParam);
}
}
ProcessInstanceMap processInstanceMap = JSONUtils.parseObject(cmdParam, ProcessInstanceMap.class);
if (processInstanceMap == null || processInstanceMap.getParentProcessInstanceId() == 0) {
return;
}
processInstanceMap.setProcessInstanceId(subProcessInstance.getId());
this.updateWorkProcessInstanceMap(processInstanceMap);
}
/**
* join parent global params into sub process.
* only the keys doesn't in sub process global would be joined.
*
* @param parentGlobalParams parentGlobalParams
* @param subGlobalParams subGlobalParams
* @return global params join
*/
private String joinGlobalParams(String parentGlobalParams, String subGlobalParams) {
List<Property> parentParams = Lists.newArrayList(JSONUtils.toList(parentGlobalParams, Property.class));
List<Property> subParams = JSONUtils.toList(subGlobalParams, Property.class);
Set<String> parentParamKeys = parentParams.stream().map(Property::getProp).collect(toSet()); |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | List<Property> extraSubParams = subParams.stream()
.filter(subProp -> !parentParamKeys.contains(subProp.getProp())).collect(Collectors.toList());
parentParams.addAll(extraSubParams);
return JSONUtils.toJsonString(parentParams);
}
/**
* initialize task instance
*
* @param taskInstance taskInstance
*/
private void initTaskInstance(TaskInstance taskInstance) {
if (!taskInstance.isSubProcess()
&& (taskInstance.getState().typeIsCancel() || taskInstance.getState().typeIsFailure())) {
taskInstance.setFlag(Flag.NO);
updateTaskInstance(taskInstance);
return;
}
taskInstance.setState(ExecutionStatus.SUBMITTED_SUCCESS);
updateTaskInstance(taskInstance);
}
/**
* retry submit task to db
*/
public TaskInstance submitTaskWithRetry(ProcessInstance processInstance, TaskInstance taskInstance, int commitRetryTimes, int commitInterval) {
int retryTimes = 1;
TaskInstance task = null;
while (retryTimes <= commitRetryTimes) {
try {
task = SpringApplicationContext.getBean(ProcessService.class).submitTask(processInstance, taskInstance); |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | if (task != null && task.getId() != 0) {
break;
}
logger.error("task commit to db failed , taskId {} has already retry {} times, please check the database", taskInstance.getId(), retryTimes);
Thread.sleep(commitInterval);
} catch (Exception e) {
logger.error("task commit to db failed", e);
}
retryTimes += 1;
}
return task;
}
/**
* submit task to db
* submit sub process to command
*
* @param processInstance processInstance
* @param taskInstance taskInstance
* @return task instance
*/
@Transactional(rollbackFor = Exception.class)
public TaskInstance submitTask(ProcessInstance processInstance, TaskInstance taskInstance) {
logger.info("start submit task : {}, instance id:{}, state: {}",
taskInstance.getName(), taskInstance.getProcessInstanceId(), processInstance.getState());
TaskInstance task = submitTaskInstanceToDB(taskInstance, processInstance);
if (task == null) {
logger.error("end submit task to db error, task name:{}, process id:{} state: {} ",
taskInstance.getName(), taskInstance.getProcessInstance(), processInstance.getState());
return null; |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | }
if (!task.getState().typeIsFinished()) {
createSubWorkProcess(processInstance, task);
}
logger.info("end submit task to db successfully:{} {} state:{} complete, instance id:{} state: {} ",
taskInstance.getId(), taskInstance.getName(), task.getState(), processInstance.getId(), processInstance.getState());
return task;
}
/**
* set work process instance map
* consider o
* repeat running does not generate new sub process instance
* set map {parent instance id, task instance id, 0(child instance id)}
*
* @param parentInstance parentInstance
* @param parentTask parentTask
* @return process instance map
*/
private ProcessInstanceMap setProcessInstanceMap(ProcessInstance parentInstance, TaskInstance parentTask) {
ProcessInstanceMap processMap = findWorkProcessMapByParent(parentInstance.getId(), parentTask.getId());
if (processMap != null) {
return processMap;
}
if (parentInstance.getCommandType() == CommandType.REPEAT_RUNNING) {
processMap = findPreviousTaskProcessMap(parentInstance, parentTask);
if (processMap != null) {
processMap.setParentTaskInstanceId(parentTask.getId());
updateWorkProcessInstanceMap(processMap);
return processMap; |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | }
}
processMap = new ProcessInstanceMap();
processMap.setParentProcessInstanceId(parentInstance.getId());
processMap.setParentTaskInstanceId(parentTask.getId());
createWorkProcessInstanceMap(processMap);
return processMap;
}
/**
* find previous task work process map.
*
* @param parentProcessInstance parentProcessInstance
* @param parentTask parentTask
* @return process instance map
*/
private ProcessInstanceMap findPreviousTaskProcessMap(ProcessInstance parentProcessInstance,
TaskInstance parentTask) {
Integer preTaskId = 0;
List<TaskInstance> preTaskList = this.findPreviousTaskListByWorkProcessId(parentProcessInstance.getId());
for (TaskInstance task : preTaskList) {
if (task.getName().equals(parentTask.getName())) {
preTaskId = task.getId();
ProcessInstanceMap map = findWorkProcessMapByParent(parentProcessInstance.getId(), preTaskId);
if (map != null) {
return map;
}
}
}
logger.info("sub process instance is not found,parent task:{},parent instance:{}", |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | parentTask.getId(), parentProcessInstance.getId());
return null;
}
/**
* create sub work process command
*
* @param parentProcessInstance parentProcessInstance
* @param task task
*/
public void createSubWorkProcess(ProcessInstance parentProcessInstance, TaskInstance task) {
if (!task.isSubProcess()) {
return;
}
ProcessInstanceMap instanceMap = findWorkProcessMapByParent(parentProcessInstance.getId(), task.getId());
if (null != instanceMap && CommandType.RECOVER_TOLERANCE_FAULT_PROCESS == parentProcessInstance.getCommandType()) {
return;
}
instanceMap = setProcessInstanceMap(parentProcessInstance, task);
ProcessInstance childInstance = null;
if (instanceMap.getProcessInstanceId() != 0) {
childInstance = findProcessInstanceById(instanceMap.getProcessInstanceId());
}
Command subProcessCommand = createSubProcessCommand(parentProcessInstance, childInstance, instanceMap, task);
updateSubProcessDefinitionByParent(parentProcessInstance, subProcessCommand.getProcessDefinitionCode());
initSubInstanceState(childInstance);
createCommand(subProcessCommand);
logger.info("sub process command created: {} ", subProcessCommand);
} |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | /**
* complement data needs transform parent parameter to child.
*/
private String getSubWorkFlowParam(ProcessInstanceMap instanceMap, ProcessInstance parentProcessInstance, Map<String, String> fatherParams) {
String processMapStr = JSONUtils.toJsonString(instanceMap);
Map<String, String> cmdParam = JSONUtils.toMap(processMapStr);
if (parentProcessInstance.isComplementData()) {
Map<String, String> parentParam = JSONUtils.toMap(parentProcessInstance.getCommandParam());
String endTime = parentParam.get(CMDPARAM_COMPLEMENT_DATA_END_DATE);
String startTime = parentParam.get(CMDPARAM_COMPLEMENT_DATA_START_DATE);
cmdParam.put(CMDPARAM_COMPLEMENT_DATA_END_DATE, endTime);
cmdParam.put(CMDPARAM_COMPLEMENT_DATA_START_DATE, startTime);
processMapStr = JSONUtils.toJsonString(cmdParam);
}
if (fatherParams.size() != 0) {
cmdParam.put(CMD_PARAM_FATHER_PARAMS, JSONUtils.toJsonString(fatherParams));
processMapStr = JSONUtils.toJsonString(cmdParam);
}
return processMapStr;
}
public Map<String, String> getGlobalParamMap(String globalParams) {
List<Property> propList;
Map<String, String> globalParamMap = new HashMap<>();
if (StringUtils.isNotEmpty(globalParams)) {
propList = JSONUtils.toList(globalParams, Property.class);
globalParamMap = propList.stream().collect(Collectors.toMap(Property::getProp, Property::getValue));
}
return globalParamMap;
} |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | /**
* create sub work process command
*/
public Command createSubProcessCommand(ProcessInstance parentProcessInstance,
ProcessInstance childInstance,
ProcessInstanceMap instanceMap,
TaskInstance task) {
CommandType commandType = getSubCommandType(parentProcessInstance, childInstance);
Map<String, String> subProcessParam = JSONUtils.toMap(task.getTaskParams());
long childDefineCode = 0L;
if (subProcessParam.containsKey(Constants.CMD_PARAM_SUB_PROCESS_DEFINE_CODE)) {
childDefineCode = Long.parseLong(subProcessParam.get(Constants.CMD_PARAM_SUB_PROCESS_DEFINE_CODE));
}
ProcessDefinition subProcessDefinition = processDefineMapper.queryByCode(childDefineCode);
Object localParams = subProcessParam.get(Constants.LOCAL_PARAMS);
List<Property> allParam = JSONUtils.toList(JSONUtils.toJsonString(localParams), Property.class);
Map<String, String> globalMap = this.getGlobalParamMap(parentProcessInstance.getGlobalParams());
Map<String, String> fatherParams = new HashMap<>();
if (CollectionUtils.isNotEmpty(allParam)) {
for (Property info : allParam) {
fatherParams.put(info.getProp(), globalMap.get(info.getProp()));
}
}
String processParam = getSubWorkFlowParam(instanceMap, parentProcessInstance, fatherParams);
int subProcessInstanceId = childInstance == null ? 0 : childInstance.getId();
return new Command(
commandType,
TaskDependType.TASK_POST,
parentProcessInstance.getFailureStrategy(),
parentProcessInstance.getExecutorId(), |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | subProcessDefinition.getCode(),
processParam,
parentProcessInstance.getWarningType(),
parentProcessInstance.getWarningGroupId(),
parentProcessInstance.getScheduleTime(),
task.getWorkerGroup(),
task.getEnvironmentCode(),
parentProcessInstance.getProcessInstancePriority(),
parentProcessInstance.getDryRun(),
subProcessInstanceId,
subProcessDefinition.getVersion()
);
}
/**
* initialize sub work flow state
* child instance state would be initialized when 'recovery from pause/stop/failure'
*/
private void initSubInstanceState(ProcessInstance childInstance) {
if (childInstance != null) {
childInstance.setState(ExecutionStatus.RUNNING_EXECUTION);
updateProcessInstance(childInstance);
}
}
/**
* get sub work flow command type
* child instance exist: child command = fatherCommand
* child instance not exists: child command = fatherCommand[0]
*/
private CommandType getSubCommandType(ProcessInstance parentProcessInstance, ProcessInstance childInstance) {
CommandType commandType = parentProcessInstance.getCommandType(); |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | if (childInstance == null) {
String fatherHistoryCommand = parentProcessInstance.getHistoryCmd();
commandType = CommandType.valueOf(fatherHistoryCommand.split(Constants.COMMA)[0]);
}
return commandType;
}
/**
* update sub process definition
*
* @param parentProcessInstance parentProcessInstance
* @param childDefinitionCode childDefinitionId
*/
private void updateSubProcessDefinitionByParent(ProcessInstance parentProcessInstance, long childDefinitionCode) {
ProcessDefinition fatherDefinition = this.findProcessDefinition(parentProcessInstance.getProcessDefinitionCode(),
parentProcessInstance.getProcessDefinitionVersion());
ProcessDefinition childDefinition = this.findProcessDefinitionByCode(childDefinitionCode);
if (childDefinition != null && fatherDefinition != null) {
childDefinition.setWarningGroupId(fatherDefinition.getWarningGroupId());
processDefineMapper.updateById(childDefinition);
}
}
/**
* submit task to mysql
*
* @param taskInstance taskInstance
* @param processInstance processInstance
* @return task instance
*/
public TaskInstance submitTaskInstanceToDB(TaskInstance taskInstance, ProcessInstance processInstance) {
ExecutionStatus processInstanceState = processInstance.getState(); |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | if (processInstanceState.typeIsFinished()
|| processInstanceState == ExecutionStatus.READY_PAUSE
|| processInstanceState == ExecutionStatus.READY_STOP) {
logger.warn("processInstance {} was {}, skip submit task", processInstance.getProcessDefinitionCode(), processInstanceState);
return null;
}
taskInstance.setExecutorId(processInstance.getExecutorId());
taskInstance.setProcessInstancePriority(processInstance.getProcessInstancePriority());
taskInstance.setState(getSubmitTaskState(taskInstance, processInstance));
if (taskInstance.getSubmitTime() == null) {
taskInstance.setSubmitTime(new Date());
}
if (taskInstance.getFirstSubmitTime() == null) {
taskInstance.setFirstSubmitTime(taskInstance.getSubmitTime());
}
boolean saveResult = saveTaskInstance(taskInstance);
if (!saveResult) {
return null;
}
return taskInstance;
}
/**
* get submit task instance state by the work process state
* cannot modify the task state when running/kill/submit success, or this
* task instance is already exists in task queue .
* return pause if work process state is ready pause
* return stop if work process state is ready stop
* if all of above are not satisfied, return submit success
*
* @param taskInstance taskInstance |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | * @param processInstance processInstance
* @return process instance state
*/
public ExecutionStatus getSubmitTaskState(TaskInstance taskInstance, ProcessInstance processInstance) {
ExecutionStatus state = taskInstance.getState();
if (
state == ExecutionStatus.RUNNING_EXECUTION
|| state == ExecutionStatus.DELAY_EXECUTION
|| state == ExecutionStatus.KILL
) {
return state;
}
if (processInstance.getState() == ExecutionStatus.READY_PAUSE) {
state = ExecutionStatus.PAUSE;
} else if (processInstance.getState() == ExecutionStatus.READY_STOP
|| !checkProcessStrategy(taskInstance, processInstance)) {
state = ExecutionStatus.KILL;
} else {
state = ExecutionStatus.SUBMITTED_SUCCESS;
}
return state;
}
/**
* check process instance strategy
* |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | * @param taskInstance taskInstance
* @return check strategy result
*/
private boolean checkProcessStrategy(TaskInstance taskInstance, ProcessInstance processInstance) {
FailureStrategy failureStrategy = processInstance.getFailureStrategy();
if (failureStrategy == FailureStrategy.CONTINUE) {
return true;
}
List<TaskInstance> taskInstances = this.findValidTaskListByProcessId(taskInstance.getProcessInstanceId());
for (TaskInstance task : taskInstances) {
if (task.getState() == ExecutionStatus.FAILURE
&& task.getRetryTimes() >= task.getMaxRetryTimes()) {
return false;
}
}
return true;
}
/**
* insert or update work process instance to data base
*
* @param processInstance processInstance
*/
public void saveProcessInstance(ProcessInstance processInstance) {
if (processInstance == null) {
logger.error("save error, process instance is null!");
return;
}
if (processInstance.getId() != 0) {
processInstanceMapper.updateById(processInstance);
} else { |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | processInstanceMapper.insert(processInstance);
}
}
/**
* insert or update command
*
* @param command command
* @return save command result
*/
public int saveCommand(Command command) {
if (command.getId() != 0) {
return commandMapper.updateById(command);
} else {
return commandMapper.insert(command);
}
}
/**
* insert or update task instance
*
* @param taskInstance taskInstance
* @return save task instance result
*/
public boolean saveTaskInstance(TaskInstance taskInstance) {
if (taskInstance.getId() != 0) {
return updateTaskInstance(taskInstance);
} else {
return createTaskInstance(taskInstance);
}
}
/** |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | * insert task instance
*
* @param taskInstance taskInstance
* @return create task instance result
*/
public boolean createTaskInstance(TaskInstance taskInstance) {
int count = taskInstanceMapper.insert(taskInstance);
return count > 0;
}
/**
* update task instance
*
* @param taskInstance taskInstance
* @return update task instance result
*/
public boolean updateTaskInstance(TaskInstance taskInstance) {
int count = taskInstanceMapper.updateById(taskInstance);
return count > 0;
}
/**
* find task instance by id
*
* @param taskId task id
* @return task instance
*/
public TaskInstance findTaskInstanceById(Integer taskId) {
return taskInstanceMapper.selectById(taskId);
}
/**
* find task instance list by id list |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | *
* @param idList task id list
* @return task instance list
*/
public List<TaskInstance> findTaskInstanceByIdList(List<Integer> idList) {
if (CollectionUtils.isEmpty(idList)) {
return new ArrayList<>();
}
return taskInstanceMapper.selectBatchIds(idList);
}
/**
* package task instance
*/
public void packageTaskInstance(TaskInstance taskInstance, ProcessInstance processInstance) {
taskInstance.setProcessInstance(processInstance);
taskInstance.setProcessDefine(processInstance.getProcessDefinition());
TaskDefinition taskDefinition = this.findTaskDefinition(
taskInstance.getTaskCode(),
taskInstance.getTaskDefinitionVersion());
this.updateTaskDefinitionResources(taskDefinition);
taskInstance.setTaskDefine(taskDefinition);
}
/**
* Update {@link ResourceInfo} information in {@link TaskDefinition}
*
* @param taskDefinition the given {@link TaskDefinition}
*/
public void updateTaskDefinitionResources(TaskDefinition taskDefinition) {
Map<String, Object> taskParameters = JSONUtils.parseObject(
taskDefinition.getTaskParams(), |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | new TypeReference<Map<String, Object>>() {
});
if (taskParameters != null) {
if (taskParameters.containsKey("mainJar")) {
Object mainJarObj = taskParameters.get("mainJar");
ResourceInfo mainJar = JSONUtils.parseObject(
JSONUtils.toJsonString(mainJarObj),
ResourceInfo.class);
ResourceInfo resourceInfo = updateResourceInfo(mainJar);
if (resourceInfo != null) {
taskParameters.put("mainJar", resourceInfo);
}
}
if (taskParameters.containsKey("resourceList")) {
String resourceListStr = JSONUtils.toJsonString(taskParameters.get("resourceList"));
List<ResourceInfo> resourceInfos = JSONUtils.toList(resourceListStr, ResourceInfo.class);
List<ResourceInfo> updatedResourceInfos = resourceInfos
.stream()
.map(this::updateResourceInfo)
.filter(Objects::nonNull)
.collect(Collectors.toList());
taskParameters.put("resourceList", updatedResourceInfos);
}
taskDefinition.setTaskParams(JSONUtils.toJsonString(taskParameters));
}
} |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | /**
* update {@link ResourceInfo} by given original ResourceInfo
*
* @param res origin resource info
* @return {@link ResourceInfo}
*/
private ResourceInfo updateResourceInfo(ResourceInfo res) {
ResourceInfo resourceInfo = null;
if (res != null) {
int resourceId = res.getId();
if (resourceId <= 0) {
logger.error("invalid resourceId, {}", resourceId);
return null;
}
resourceInfo = new ResourceInfo();
Resource resource = getResourceById(resourceId);
resourceInfo.setId(resourceId);
resourceInfo.setRes(resource.getFileName());
resourceInfo.setResourceName(resource.getFullName());
if (logger.isInfoEnabled()) {
logger.info("updated resource info {}",
JSONUtils.toJsonString(resourceInfo));
}
}
return resourceInfo;
}
/**
* get id list by task state |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | *
* @param instanceId instanceId
* @param state state
* @return task instance states
*/
public List<Integer> findTaskIdByInstanceState(int instanceId, ExecutionStatus state) {
return taskInstanceMapper.queryTaskByProcessIdAndState(instanceId, state.ordinal());
}
/**
* find valid task list by process definition id
*
* @param processInstanceId processInstanceId
* @return task instance list
*/
public List<TaskInstance> findValidTaskListByProcessId(Integer processInstanceId) {
return taskInstanceMapper.findValidTaskListByProcessId(processInstanceId, Flag.YES);
}
/**
* find previous task list by work process id
*
* @param processInstanceId processInstanceId
* @return task instance list
*/
public List<TaskInstance> findPreviousTaskListByWorkProcessId(Integer processInstanceId) {
return taskInstanceMapper.findValidTaskListByProcessId(processInstanceId, Flag.NO);
}
/**
* update work process instance map
*
* @param processInstanceMap processInstanceMap |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | * @return update process instance result
*/
public int updateWorkProcessInstanceMap(ProcessInstanceMap processInstanceMap) {
return processInstanceMapMapper.updateById(processInstanceMap);
}
/**
* create work process instance map
*
* @param processInstanceMap processInstanceMap
* @return create process instance result
*/
public int createWorkProcessInstanceMap(ProcessInstanceMap processInstanceMap) {
int count = 0;
if (processInstanceMap != null) {
return processInstanceMapMapper.insert(processInstanceMap);
}
return count;
}
/**
* find work process map by parent process id and parent task id.
*
* @param parentWorkProcessId parentWorkProcessId
* @param parentTaskId parentTaskId
* @return process instance map
*/
public ProcessInstanceMap findWorkProcessMapByParent(Integer parentWorkProcessId, Integer parentTaskId) {
return processInstanceMapMapper.queryByParentId(parentWorkProcessId, parentTaskId);
}
/**
* delete work process map by parent process id |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | *
* @param parentWorkProcessId parentWorkProcessId
* @return delete process map result
*/
public int deleteWorkProcessMapByParentId(int parentWorkProcessId) {
return processInstanceMapMapper.deleteByParentProcessId(parentWorkProcessId);
}
/**
* find sub process instance
*
* @param parentProcessId parentProcessId
* @param parentTaskId parentTaskId
* @return process instance
*/
public ProcessInstance findSubProcessInstance(Integer parentProcessId, Integer parentTaskId) {
ProcessInstance processInstance = null;
ProcessInstanceMap processInstanceMap = processInstanceMapMapper.queryByParentId(parentProcessId, parentTaskId);
if (processInstanceMap == null || processInstanceMap.getProcessInstanceId() == 0) {
return processInstance;
}
processInstance = findProcessInstanceById(processInstanceMap.getProcessInstanceId());
return processInstance;
}
/**
* find parent process instance
*
* @param subProcessId subProcessId
* @return process instance
*/
public ProcessInstance findParentProcessInstance(Integer subProcessId) { |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | ProcessInstance processInstance = null;
ProcessInstanceMap processInstanceMap = processInstanceMapMapper.queryBySubProcessId(subProcessId);
if (processInstanceMap == null || processInstanceMap.getProcessInstanceId() == 0) {
return processInstance;
}
processInstance = findProcessInstanceById(processInstanceMap.getParentProcessInstanceId());
return processInstance;
}
/**
* change task state
*
* @param state state
* @param startTime startTime
* @param host host
* @param executePath executePath
* @param logPath logPath
*/
public void changeTaskState(TaskInstance taskInstance,
ExecutionStatus state,
Date startTime,
String host,
String executePath,
String logPath) {
taskInstance.setState(state);
taskInstance.setStartTime(startTime);
taskInstance.setHost(host);
taskInstance.setExecutePath(executePath);
taskInstance.setLogPath(logPath);
saveTaskInstance(taskInstance);
} |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | /**
* update process instance
*
* @param processInstance processInstance
* @return update process instance result
*/
public int updateProcessInstance(ProcessInstance processInstance) {
return processInstanceMapper.updateById(processInstance);
}
/**
* change task state
*
* @param state state
* @param endTime endTime
* @param varPool varPool
*/
public void changeTaskState(TaskInstance taskInstance, ExecutionStatus state,
Date endTime,
int processId,
String appIds,
String varPool) {
taskInstance.setPid(processId);
taskInstance.setAppLink(appIds);
taskInstance.setState(state);
taskInstance.setEndTime(endTime);
taskInstance.setVarPool(varPool);
changeOutParam(taskInstance);
saveTaskInstance(taskInstance);
}
/** |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | * for show in page of taskInstance
*/
public void changeOutParam(TaskInstance taskInstance) {
if (StringUtils.isEmpty(taskInstance.getVarPool())) {
return;
}
List<Property> properties = JSONUtils.toList(taskInstance.getVarPool(), Property.class);
if (CollectionUtils.isEmpty(properties)) {
return;
}
Map<String, Object> taskParams = JSONUtils.parseObject(taskInstance.getTaskParams(), new TypeReference<Map<String, Object>>() {
});
Object localParams = taskParams.get(LOCAL_PARAMS);
if (localParams == null) {
return;
}
List<Property> allParam = JSONUtils.toList(JSONUtils.toJsonString(localParams), Property.class);
Map<String, String> outProperty = new HashMap<>();
for (Property info : properties) {
if (info.getDirect() == Direct.OUT) {
outProperty.put(info.getProp(), info.getValue());
}
}
for (Property info : allParam) {
if (info.getDirect() == Direct.OUT) {
String paramName = info.getProp();
info.setValue(outProperty.get(paramName));
}
} |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | taskParams.put(LOCAL_PARAMS, allParam);
taskInstance.setTaskParams(JSONUtils.toJsonString(taskParams));
}
/**
* convert integer list to string list
*
* @param intList intList
* @return string list
*/
public List<String> convertIntListToString(List<Integer> intList) {
if (intList == null) {
return new ArrayList<>();
}
List<String> result = new ArrayList<>(intList.size());
for (Integer intVar : intList) {
result.add(String.valueOf(intVar));
}
return result;
}
/**
* query schedule by id
*
* @param id id
* @return schedule
*/
public Schedule querySchedule(int id) {
return scheduleMapper.selectById(id);
}
/**
* query Schedule by processDefinitionCode |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | *
* @param processDefinitionCode processDefinitionCode
* @see Schedule
*/
public List<Schedule> queryReleaseSchedulerListByProcessDefinitionCode(long processDefinitionCode) {
return scheduleMapper.queryReleaseSchedulerListByProcessDefinitionCode(processDefinitionCode);
}
/**
* query Schedule by processDefinitionCode
*
* @param processDefinitionCodeList processDefinitionCodeList
* @see Schedule
*/
public Map<Long, String> queryWorkerGroupByProcessDefinitionCodes(List<Long> processDefinitionCodeList) {
List<Schedule> processDefinitionScheduleList = scheduleMapper.querySchedulesByProcessDefinitionCodes(processDefinitionCodeList);
return processDefinitionScheduleList.stream().collect(Collectors.toMap(Schedule::getProcessDefinitionCode,
Schedule::getWorkerGroup));
}
/**
* query dependent process definition by process definition code
*
* @param processDefinitionCode processDefinitionCode
* @see DependentProcessDefinition
*/
public List<DependentProcessDefinition> queryDependentProcessDefinitionByProcessDefinitionCode(long processDefinitionCode) {
return workFlowLineageMapper.queryDependentProcessDefinitionByProcessDefinitionCode(processDefinitionCode);
}
/**
* query need failover process instance
* |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | * @param host host
* @return process instance list
*/
public List<ProcessInstance> queryNeedFailoverProcessInstances(String host) {
return processInstanceMapper.queryByHostAndStatus(host, stateArray);
}
public List<String> queryNeedFailoverProcessInstanceHost() {
return processInstanceMapper.queryNeedFailoverProcessInstanceHost(stateArray);
}
/**
* process need failover process instance
*
* @param processInstance processInstance
*/
@Transactional(rollbackFor = RuntimeException.class)
public void processNeedFailoverProcessInstances(ProcessInstance processInstance) {
processInstance.setHost(Constants.NULL);
processInstanceMapper.updateById(processInstance);
ProcessDefinition processDefinition = findProcessDefinition(processInstance.getProcessDefinitionCode(), processInstance.getProcessDefinitionVersion());
Command cmd = new Command();
cmd.setProcessDefinitionCode(processDefinition.getCode());
cmd.setProcessDefinitionVersion(processDefinition.getVersion());
cmd.setProcessInstanceId(processInstance.getId());
cmd.setCommandParam(String.format("{\"%s\":%d}", Constants.CMD_PARAM_RECOVER_PROCESS_ID_STRING, processInstance.getId()));
cmd.setExecutorId(processInstance.getExecutorId());
cmd.setCommandType(CommandType.RECOVER_TOLERANCE_FAULT_PROCESS);
createCommand(cmd);
} |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | /**
* query all need failover task instances by host
*
* @param host host
* @return task instance list
*/
public List<TaskInstance> queryNeedFailoverTaskInstances(String host) {
return taskInstanceMapper.queryByHostAndStatus(host,
stateArray);
}
/**
* find data source by id
*
* @param id id
* @return datasource
*/
public DataSource findDataSourceById(int id) {
return dataSourceMapper.selectById(id);
}
/**
* update process instance state by id
*
* @param processInstanceId processInstanceId
* @param executionStatus executionStatus
* @return update process result
*/
public int updateProcessInstanceState(Integer processInstanceId, ExecutionStatus executionStatus) {
ProcessInstance instance = processInstanceMapper.selectById(processInstanceId);
instance.setState(executionStatus);
return processInstanceMapper.updateById(instance); |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | }
/**
* find process instance by the task id
*
* @param taskId taskId
* @return process instance
*/
public ProcessInstance findProcessInstanceByTaskId(int taskId) {
TaskInstance taskInstance = taskInstanceMapper.selectById(taskId);
if (taskInstance != null) {
return processInstanceMapper.selectById(taskInstance.getProcessInstanceId());
}
return null;
}
/**
* find udf function list by id list string
*
* @param ids ids
* @return udf function list
*/
public List<UdfFunc> queryUdfFunListByIds(Integer[] ids) {
return udfFuncMapper.queryUdfByIdStr(ids, null);
}
/**
* find tenant code by resource name
*
* @param resName resource name
* @param resourceType resource type
* @return tenant code
*/ |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | public String queryTenantCodeByResName(String resName, ResourceType resourceType) {
String fullName = resName.startsWith("/") ? resName : String.format("/%s", resName);
List<Resource> resourceList = resourceMapper.queryResource(fullName, resourceType.ordinal());
if (CollectionUtils.isEmpty(resourceList)) {
return StringUtils.EMPTY;
}
int userId = resourceList.get(0).getUserId();
User user = userMapper.selectById(userId);
if (Objects.isNull(user)) {
return StringUtils.EMPTY;
}
Tenant tenant = tenantMapper.queryById(user.getTenantId());
if (Objects.isNull(tenant)) {
return StringUtils.EMPTY;
}
return tenant.getTenantCode();
}
/**
* find schedule list by process define codes.
*
* @param codes codes
* @return schedule list
*/
public List<Schedule> selectAllByProcessDefineCode(long[] codes) {
return scheduleMapper.selectAllByProcessDefineArray(codes);
}
/**
* find last scheduler process instance in the date interval
* |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | * @param definitionCode definitionCode
* @param dateInterval dateInterval
* @return process instance
*/
public ProcessInstance findLastSchedulerProcessInterval(Long definitionCode, DateInterval dateInterval) {
return processInstanceMapper.queryLastSchedulerProcess(definitionCode,
dateInterval.getStartTime(),
dateInterval.getEndTime());
}
/**
* find last manual process instance interval
*
* @param definitionCode process definition code
* @param dateInterval dateInterval
* @return process instance
*/
public ProcessInstance findLastManualProcessInterval(Long definitionCode, DateInterval dateInterval) {
return processInstanceMapper.queryLastManualProcess(definitionCode,
dateInterval.getStartTime(),
dateInterval.getEndTime());
}
/**
* find last running process instance
*
* @param definitionCode process definition code
* @param startTime start time
* @param endTime end time
* @return process instance
*/
public ProcessInstance findLastRunningProcess(Long definitionCode, Date startTime, Date endTime) { |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | return processInstanceMapper.queryLastRunningProcess(definitionCode,
startTime,
endTime,
stateArray);
}
/**
* query user queue by process instance
*
* @param processInstance processInstance
* @return queue
*/
public String queryUserQueueByProcessInstance(ProcessInstance processInstance) {
String queue = "";
if (processInstance == null) {
return queue;
}
User executor = userMapper.selectById(processInstance.getExecutorId());
if (executor != null) {
queue = executor.getQueue();
}
return queue;
}
/**
* query project name and user name by processInstanceId.
*
* @param processInstanceId processInstanceId
* @return projectName and userName
*/
public ProjectUser queryProjectWithUserByProcessInstanceId(int processInstanceId) {
return projectMapper.queryProjectWithUserByProcessInstanceId(processInstanceId); |
closed | apache/dolphinscheduler | https://github.com/apache/dolphinscheduler | 9,227 | [Improvement][Master] use the slot to scan the database | ### Search before asking
- [X] I had searched in the [issues](https://github.com/apache/dolphinscheduler/issues?q=is%3Aissue) and found no similar feature requirement.
### Description
When the master assigns tasks by slot, it is inefficient to obtain commands by cyclically scanning the database.
Can we use the slot to scan the database?
I have an idea.
such as:
select * from t_ds_command where id % masterCount = thisMasterSlot;
the masterCount and thisMasterSlot is the parameter
（Associate org.apache.dolphinscheduler.server.master.runner.MasterSchedulerService）
### Use case
Improve the efficiency of the master assigning tasks through slots
### Related issues
_No response_
### Are you willing to submit a PR?
- [X] Yes I am willing to submit a PR!
### Code of Conduct
- [X] I agree to follow this project's [Code of Conduct](https://www.apache.org/foundation/policies/conduct)
| https://github.com/apache/dolphinscheduler/issues/9227 | https://github.com/apache/dolphinscheduler/pull/9228 | 263791a63e4b85f96563eda51704816d2c38e600 | d3251c9bcc5744905723df7fab11a676029e7d6e | 2022-03-27T16:04:51Z | java | 2022-03-28T01:52:12Z | dolphinscheduler-service/src/main/java/org/apache/dolphinscheduler/service/process/ProcessService.java | }
/**
* get task worker group
*
* @param taskInstance taskInstance
* @return workerGroupId
*/
public String getTaskWorkerGroup(TaskInstance taskInstance) {
String workerGroup = taskInstance.getWorkerGroup();
if (StringUtils.isNotBlank(workerGroup)) {
return workerGroup;
}
int processInstanceId = taskInstance.getProcessInstanceId();
ProcessInstance processInstance = findProcessInstanceById(processInstanceId);
if (processInstance != null) {
return processInstance.getWorkerGroup();
}
logger.info("task : {} will use default worker group", taskInstance.getId());
return Constants.DEFAULT_WORKER_GROUP;
}
/**
* get have perm project list
*
* @param userId userId
* @return project list
*/
public List<Project> getProjectListHavePerm(int userId) {
List<Project> createProjects = projectMapper.queryProjectCreatedByUser(userId);
List<Project> authedProjects = projectMapper.queryAuthedProjectListByUserId(userId);
if (createProjects == null) { |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.