Skip to content

The Unified and Autonomous Development Platform

feat: Able to specify sequential group of jobs to control job cocurrency (OD-1914)

Robin Shen67757a93f579
diff --git a/server-core/src/main/java/io/onedev/server/buildspec/job/Job.java b/server-core/src/main/java/io/onedev/server/buildspec/job/Job.java
index 0280c24421..4571fa62ef 100644
--- a/server-core/src/main/java/io/onedev/server/buildspec/job/Job.java
+++ b/server-core/src/main/java/io/onedev/server/buildspec/job/Job.java
@@ -87,6 +87,8 @@ public class Job implements NamedElement, Serializable, Validatable {
private List<PostBuildAction> postBuildActions = new ArrayList<>();
+ private String sequentialGroup;
+
private String retryCondition = "never";
private int maxRetries = 3;
@@ -241,6 +243,19 @@ public class Job implements NamedElement, Serializable, Validatable {
return choices;
}
+ @Editable(order=9300, group="More Settings", description = "Jobs with same sequential group and executor will be " +
+ "executed sequentially. For instance you may specify this property as <tt>@project_path@:prod</tt> for " +
+ "jobs executing by same executor and deploying to prod environment of current project to avoid " +
+ "conflicting deployments")
+ @Interpolative(variableSuggester="suggestVariables")
+ public String getSequentialGroup() {
+ return sequentialGroup;
+ }
+
+ public void setSequentialGroup(String sequentialGroup) {
+ this.sequentialGroup = sequentialGroup;
+ }
+
@Editable(order=9400, group="More Settings", description="Specify condition to retry build upon failure")
@NotEmpty
@RetryCondition
diff --git a/server-core/src/main/java/io/onedev/server/entitymanager/impl/DefaultAgentManager.java b/server-core/src/main/java/io/onedev/server/entitymanager/impl/DefaultAgentManager.java
index 92a5fd4d03..0b9e3d4f08 100644
--- a/server-core/src/main/java/io/onedev/server/entitymanager/impl/DefaultAgentManager.java
+++ b/server-core/src/main/java/io/onedev/server/entitymanager/impl/DefaultAgentManager.java
@@ -187,7 +187,7 @@ public class DefaultAgentManager extends BaseEntityManager<Agent> implements Age
agent.setOsVersion(data.getOsInfo().getOsVersion());
agent.setOsArch(data.getOsInfo().getOsArch());
agent.setName(data.getName());
- agent.setCpus(data.getCpus());
+ agent.setCpuCount(data.getCpus());
agent.setIpAddress(data.getIpAddress());
AgentLastUsedDate lastUsedDate = new AgentLastUsedDate();
@@ -212,7 +212,7 @@ public class DefaultAgentManager extends BaseEntityManager<Agent> implements Age
agent.setOsVersion(data.getOsInfo().getOsVersion());
agent.setOsArch(data.getOsInfo().getOsArch());
agent.setIpAddress(data.getIpAddress());
- agent.setCpus(data.getCpus());
+ agent.setCpuCount(data.getCpus());
dao.persist(agent);
attributeManager.syncAttributes(agent, data.getAttributes());
}
diff --git a/server-core/src/main/java/io/onedev/server/job/DefaultJobManager.java b/server-core/src/main/java/io/onedev/server/job/DefaultJobManager.java
index 68e781814d..e8cfebbceb 100644
--- a/server-core/src/main/java/io/onedev/server/job/DefaultJobManager.java
+++ b/server-core/src/main/java/io/onedev/server/job/DefaultJobManager.java
@@ -76,6 +76,7 @@ import io.onedev.server.web.editable.EditableUtils;
import nl.altindag.ssl.SSLFactory;
import org.apache.shiro.authz.UnauthorizedException;
import org.apache.shiro.subject.Subject;
+import org.apache.wicket.util.collections.ConcurrentHashSet;
import org.eclipse.jgit.lib.ObjectId;
import org.joda.time.DateTime;
import org.quartz.CronExpression;
@@ -174,8 +175,9 @@ public class DefaultJobManager implements JobManager, Runnable, CodePullAuthoriz
private final Map<String, JobContext> jobContexts = new ConcurrentHashMap<>();
private volatile IMap<String, String> jobServers;
-
-
+
+ private volatile IMap<String, Date> sequentialKeys;
+
private volatile Map<String, List<JobSchedule>> branchSchedules;
private volatile String maintenanceTaskId;
@@ -519,8 +521,13 @@ public class DefaultJobManager implements JobManager, Runnable, CodePullAuthoriz
Collection<String> jobSecretsToMask = Sets.newHashSet(jobToken, clusterManager.getCredential());
TaskLogger jobLogger = logManager.newLogger(build, jobSecretsToMask);
String jobExecutorName = interpolator.interpolate(build.getJob().getJobExecutor());
-
JobExecutor jobExecutor = getJobExecutor(build, jobExecutorName, jobLogger);
+ String sequentialGroup = interpolator.interpolate(build.getJob().getSequentialGroup());
+ String sequentialKey;
+ if (sequentialGroup != null)
+ sequentialKey = jobExecutorName + ":" + sequentialGroup;
+ else
+ sequentialKey = null;
Long projectId = build.getProject().getId();
String projectPath = build.getProject().getPath();
String projectGitDir = projectManager.getGitDir(build.getProject().getId()).getAbsolutePath();
@@ -556,34 +563,45 @@ public class DefaultJobManager implements JobManager, Runnable, CodePullAuthoriz
JobAuthorizationContext.pop();
}
- JobContext jobContext = new JobContext(jobToken, jobExecutor, projectId, projectPath,
- projectGitDir, buildId, buildNumber, actions, refName, commitId, services,
- timeout);
+ JobContext jobContext = new JobContext(jobToken, jobExecutor, sequentialGroup,
+ projectId, projectPath, projectGitDir, buildId, buildNumber, actions,
+ refName, commitId, services, timeout);
return new JobExecution(executorService.submit(() -> {
- while (true) {
- // Store original job actions as the copy in job context will be fetched from cluster and
- // some transient fields (such as step object in ServerSideFacade) will not be preserved
- jobActions.put(jobToken, actions);
- logManager.addJobLogger(jobToken, jobLogger);
- serverStepThreads.put(jobToken, new ArrayList<>());
- try {
- if (jobExecutor.execute(jobContext, jobLogger))
- return true;
- if (!retryJob(job, jobContext, jobLogger, null))
- return false;
- } catch (Throwable e) {
- if (!retryJob(job, jobContext, jobLogger, e))
- throw e;
- } finally {
- Collection<Thread> threads = serverStepThreads.remove(jobToken);
- synchronized (threads) {
- for (Thread thread : threads)
- thread.interrupt();
+ if (sequentialKey != null) {
+ jobLogger.log("Locking sequential group...");
+ while (sequentialKeys.putIfAbsent(sequentialKey, new Date(), timeout, TimeUnit.SECONDS) != null) {
+ Thread.sleep(1000);
+ }
+ }
+ try {
+ while (true) {
+ // Store original job actions as the copy in job context will be fetched from cluster and
+ // some transient fields (such as step object in ServerSideFacade) will not be preserved
+ jobActions.put(jobToken, actions);
+ logManager.addJobLogger(jobToken, jobLogger);
+ serverStepThreads.put(jobToken, new ArrayList<>());
+ try {
+ if (jobExecutor.execute(jobContext, jobLogger))
+ return true;
+ if (!retryJob(job, jobContext, jobLogger, null))
+ return false;
+ } catch (Throwable e) {
+ if (!retryJob(job, jobContext, jobLogger, e))
+ throw e;
+ } finally {
+ Collection<Thread> threads = serverStepThreads.remove(jobToken);
+ synchronized (threads) {
+ for (Thread thread : threads)
+ thread.interrupt();
+ }
+ logManager.removeJobLogger(jobToken);
+ jobActions.remove(jobToken);
}
- logManager.removeJobLogger(jobToken);
- jobActions.remove(jobToken);
}
+ } finally {
+ if (sequentialKey != null)
+ sequentialKeys.remove(sequentialKey);
}
}), job.getTimeout() * 1000L);
}
@@ -974,7 +992,8 @@ public class DefaultJobManager implements JobManager, Runnable, CodePullAuthoriz
public void on(SystemStarting event) {
var hazelcastInstance = clusterManager.getHazelcastInstance();
jobServers = hazelcastInstance.getMap("jobServers");
- branchSchedules = hazelcastInstance.getReplicatedMap("jobSchedules");
+ sequentialKeys = hazelcastInstance.getMap("seqentialKeys");
+ branchSchedules = hazelcastInstance.getReplicatedMap("branchSchedules");
}
private void cacheBranchSchedules(Project project, String branch, ObjectId commitId) {
diff --git a/server-core/src/main/java/io/onedev/server/job/DefaultResourceAllocator.java b/server-core/src/main/java/io/onedev/server/job/DefaultResourceAllocator.java
index ae1ec1326e..d8653dfde7 100644
--- a/server-core/src/main/java/io/onedev/server/job/DefaultResourceAllocator.java
+++ b/server-core/src/main/java/io/onedev/server/job/DefaultResourceAllocator.java
@@ -55,19 +55,19 @@ public class DefaultResourceAllocator implements ResourceAllocator, Serializable
private final TaskScheduler taskScheduler;
- private volatile Map<String, Integer> nodeCpus;
+ private volatile Map<String, Integer> cpuCounts;
- private final Map<String, Integer> resourceUsages = new HashMap<>();
+ private final Map<String, Integer> concurrencyUsages = new HashMap<>();
+
+ private volatile Map<String, Integer> concurrencyUsagesCache;
- private volatile Map<String, Integer> resourceUsagesCache;
-
private volatile Map<Long, Long> disconnectingAgents;
private volatile String taskId;
@Inject
public DefaultResourceAllocator(AgentManager agentManager, TransactionManager transactionManager,
- ClusterManager clusterManager, JobManager jobManager,
+ ClusterManager clusterManager, JobManager jobManager,
TaskScheduler taskScheduler) {
this.agentManager = agentManager;
this.transactionManager = transactionManager;
@@ -84,25 +84,25 @@ public class DefaultResourceAllocator implements ResourceAllocator, Serializable
public void on(SystemStarting event) {
HazelcastInstance hazelcastInstance = clusterManager.getHazelcastInstance();
- nodeCpus = hazelcastInstance.getReplicatedMap("nodeCpus");
+ cpuCounts = hazelcastInstance.getReplicatedMap("cpuCounts");
var localServer = clusterManager.getLocalServerAddress();
try {
- nodeCpus.put(
+ cpuCounts.put(
localServer,
new SystemInfo().getHardware().getProcessor().getLogicalProcessorCount());
} catch (Exception e) {
logger.debug("Error calling oshi", e);
- nodeCpus.put(localServer, 4);
+ cpuCounts.put(localServer, 4);
}
- resourceUsagesCache = hazelcastInstance.getReplicatedMap("resourceUsagesCache");
+ concurrencyUsagesCache = hazelcastInstance.getReplicatedMap("concurrencyUsagesCache");
disconnectingAgents = hazelcastInstance.getReplicatedMap("disconnectingAgents");
- removeNodeFromResourceUsagesCache(localServer);
+ removeNodeFromConcurrencyUsagesCache(localServer);
}
@Listen
public void on(SystemStopped event) {
- if (nodeCpus != null)
- nodeCpus.remove(clusterManager.getLocalServerAddress());
+ if (cpuCounts != null)
+ cpuCounts.remove(clusterManager.getLocalServerAddress());
}
@Listen
@@ -122,42 +122,42 @@ public class DefaultResourceAllocator implements ResourceAllocator, Serializable
clusterManager.submitToServer(event.getServer(), () -> {
try {
while (true) {
- synchronized (resourceUsages) {
- if (resourceUsagesCache != null) {
- resourceUsagesCache.putAll(resourceUsages);
+ synchronized (concurrencyUsages) {
+ if (concurrencyUsagesCache != null) {
+ concurrencyUsagesCache.putAll(concurrencyUsages);
break;
}
}
Thread.sleep(100);
}
} catch (Exception e) {
- logger.error("Error syncing resource usages cache", e);
+ logger.error("Error syncing concurrency usages cache", e);
}
return null;
});
}
}
- private void removeNodeFromResourceUsagesCache(String resourceNode) {
- var keysToRemove = resourceUsagesCache.keySet().stream()
- .filter(it -> it.startsWith(resourceNode + ":"))
+ private void removeNodeFromConcurrencyUsagesCache(String node) {
+ var keysToRemove = concurrencyUsagesCache.keySet().stream()
+ .filter(it -> it.startsWith(node + ":"))
.collect(toList());
for (var key: keysToRemove)
- resourceUsagesCache.remove(key);
+ concurrencyUsagesCache.remove(key);
}
@Transactional
@Listen
public void on(AgentConnected event) {
var agentId = event.getAgent().getId();
- var agentCpus = event.getAgent().getCpus();
+ var agentCpuCount = event.getAgent().getCpuCount();
transactionManager.runAfterCommit(() -> {
- nodeCpus.put(String.valueOf(agentId), agentCpus);
- removeNodeFromResourceUsagesCache(agentId.toString());
- synchronized (resourceUsages) {
- for (var entry : resourceUsages.entrySet()) {
+ cpuCounts.put(String.valueOf(agentId), agentCpuCount);
+ removeNodeFromConcurrencyUsagesCache(agentId.toString());
+ synchronized (concurrencyUsages) {
+ for (var entry : concurrencyUsages.entrySet()) {
if (entry.getKey().startsWith(agentId + ":"))
- resourceUsagesCache.put(entry.getKey(), entry.getValue());
+ concurrencyUsagesCache.put(entry.getKey(), entry.getValue());
}
}
disconnectingAgents.remove(agentId);
@@ -169,13 +169,13 @@ public class DefaultResourceAllocator implements ResourceAllocator, Serializable
public void on(AgentDisconnected event) {
var agentId = event.getAgent().getId();
transactionManager.runAfterCommit(() -> {
- nodeCpus.remove(String.valueOf(agentId));
+ cpuCounts.remove(String.valueOf(agentId));
});
}
- private int getAllocationScore(int totalResources, int usedResources, int requiredResources) {
- if (usedResources + requiredResources <= totalResources)
- return totalResources * 100 / (usedResources + requiredResources);
+ private int getAllocationScore(int totalConcurrency, int usedConcurrency, int requiredConcurrency) {
+ if (usedConcurrency + requiredConcurrency <= totalConcurrency)
+ return totalConcurrency * 100 / (usedConcurrency + requiredConcurrency);
else
return 0;
}
@@ -190,8 +190,8 @@ public class DefaultResourceAllocator implements ResourceAllocator, Serializable
disconnectingAgents.put(agentId, agentId);
while (true) {
boolean idle = true;
- synchronized (resourceUsages) {
- for (var entry : resourceUsages.entrySet()) {
+ synchronized (concurrencyUsages) {
+ for (var entry : concurrencyUsages.entrySet()) {
if (entry.getKey().startsWith(agentId + ":") && entry.getValue() > 0) {
idle = false;
break;
@@ -210,11 +210,11 @@ public class DefaultResourceAllocator implements ResourceAllocator, Serializable
}
}
- private int getEffectiveTotalResources(String resourceNode, int totalResources) {
- if (totalResources != 0) {
- return totalResources;
+ private int getEffectiveTotalConcurrency(String node, int totalConcurrency) {
+ if (totalConcurrency != 0) {
+ return totalConcurrency;
} else {
- var cpu = nodeCpus.get(resourceNode);
+ var cpu = cpuCounts.get(node);
if (cpu != null)
return cpu;
else
@@ -223,35 +223,35 @@ public class DefaultResourceAllocator implements ResourceAllocator, Serializable
}
@Nullable
- private String allocateResource(Collection<String> resourceNodes, String resourceType,
- int totalResources, int requiredResources) {
- String allocated = null;
+ private String allocateNode(Collection<String> nodes, String executorName,
+ int totalConcurrency, int requiredConcurrency) {
+ String allocatedNode = null;
var maxScore = 0;
- for (var resourceNode: resourceNodes) {
- var effectiveTotalResources = getEffectiveTotalResources(resourceNode, totalResources);
- var usedResources = resourceUsagesCache.get(resourceNode + ":" + resourceType);
- if (usedResources == null)
- usedResources = 0;
- var score = getAllocationScore(effectiveTotalResources, usedResources, requiredResources);
+ for (var node: nodes) {
+ var effectiveTotalConcurrency = getEffectiveTotalConcurrency(node, totalConcurrency);
+ var usedConcurrency = concurrencyUsagesCache.get(node + ":" + executorName);
+ if (usedConcurrency == null)
+ usedConcurrency = 0;
+ var score = getAllocationScore(effectiveTotalConcurrency, usedConcurrency, requiredConcurrency);
if (score > maxScore) {
- allocated = resourceNode;
+ allocatedNode = node;
maxScore = score;
}
}
- return allocated;
+ return allocatedNode;
}
- private void acquireResource(String resourceKey, int totalResources, int acquireResources) {
+ private void acquireConcurrency(String concurrencyKey, int totalConcurrency, int acquireConcurrency) {
while (true) {
- synchronized (resourceUsages) {
- var usedResources = resourceUsages.get(resourceKey);
- if (usedResources == null)
- usedResources = 0;
- usedResources += acquireResources;
- if (usedResources <= totalResources) {
- resourceUsages.put(resourceKey, usedResources);
- resourceUsagesCache.put(resourceKey, usedResources);
+ synchronized (concurrencyUsages) {
+ var usedCocurrency = concurrencyUsages.get(concurrencyKey);
+ if (usedCocurrency == null)
+ usedCocurrency = 0;
+ usedCocurrency += acquireConcurrency;
+ if (usedCocurrency <= totalConcurrency) {
+ concurrencyUsages.put(concurrencyKey, usedCocurrency);
+ concurrencyUsagesCache.put(concurrencyKey, usedCocurrency);
break;
}
}
@@ -263,31 +263,31 @@ public class DefaultResourceAllocator implements ResourceAllocator, Serializable
}
}
- private void releaseResource(String resourceKey, int releaseResources) {
- synchronized (resourceUsages) {
- var usedResources = resourceUsages.get(resourceKey);
- usedResources -= releaseResources;
- resourceUsages.put(resourceKey, usedResources);
- resourceUsagesCache.put(resourceKey, usedResources);
+ private void releaseConcurrency(String concurrencyKey, int releaseConcurrency) {
+ synchronized (concurrencyUsages) {
+ var usedResources = concurrencyUsages.get(concurrencyKey);
+ usedResources -= releaseConcurrency;
+ concurrencyUsages.put(concurrencyKey, usedResources);
+ concurrencyUsagesCache.put(concurrencyKey, usedResources);
}
}
@Override
- public boolean runServerJob(String resourceType, int totalResources,
- int requiredResources, ClusterTask<Boolean> runnable) {
+ public boolean runServerJob(String executorName, int totalConcurrency,
+ int requiredConcurrency, ClusterTask<Boolean> runnable) {
while (true) {
var servers = clusterManager.getServerAddresses();
servers.retainAll(clusterManager.getOnlineServers());
- var server = allocateResource(servers, resourceType, totalResources, requiredResources);
+ var server = allocateNode(servers, executorName, totalConcurrency, requiredConcurrency);
if (server != null) {
return jobManager.runJob(server, () -> {
- int effectiveTotalResources = getEffectiveTotalResources(server, totalResources);
- var resourceKey = server + ":" + resourceType;
- acquireResource(resourceKey, effectiveTotalResources, requiredResources);
+ int effectiveTotalConcurrency = getEffectiveTotalConcurrency(server, totalConcurrency);
+ var concurrencyKey = server + ":" + executorName;
+ acquireConcurrency(concurrencyKey, effectiveTotalConcurrency, requiredConcurrency);
try {
return jobManager.runJob(server, runnable);
} finally {
- releaseResource(resourceKey, requiredResources);
+ releaseConcurrency(concurrencyKey, requiredConcurrency);
}
});
}
@@ -300,8 +300,8 @@ public class DefaultResourceAllocator implements ResourceAllocator, Serializable
}
@Override
- public boolean runAgentJob(AgentQuery agentQuery, String resourceType,
- int totalResources, int requiredResources,
+ public boolean runAgentJob(AgentQuery agentQuery, String executorName,
+ int totalConcurrency, int requiredConcurrency,
AgentRunnable runnable) {
while (true) {
var agentIds = agentManager.query(agentQuery, 0, MAX_VALUE)
@@ -309,9 +309,9 @@ public class DefaultResourceAllocator implements ResourceAllocator, Serializable
.map(AbstractEntity::getId)
.collect(toSet());
agentIds.removeAll(disconnectingAgents.keySet());
- var agentIdString = allocateResource(
+ var agentIdString = allocateNode(
agentIds.stream().map(Object::toString).collect(toList()),
- resourceType, totalResources, requiredResources);
+ executorName, totalConcurrency, requiredConcurrency);
var agentId = agentIdString != null? Long.valueOf(agentIdString): null;
if (agentId != null) {
var server = agentManager.getAgentServer(agentId);
@@ -319,14 +319,14 @@ public class DefaultResourceAllocator implements ResourceAllocator, Serializable
throw new ExplicitException("Can not find server managing allocated agent, please retry later");
return jobManager.runJob(server, () -> {
- var effectiveTotalResources = getEffectiveTotalResources(agentIdString, totalResources);
- var resourceKey = agentId + ":" + resourceType;
- acquireResource(resourceKey, effectiveTotalResources, requiredResources);
+ var effectiveTotalConcurrency = getEffectiveTotalConcurrency(agentIdString, totalConcurrency);
+ var concurrencyKey = agentId + ":" + executorName;
+ acquireConcurrency(concurrencyKey, effectiveTotalConcurrency, requiredConcurrency);
try {
updateLastUsedDate(agentId);
return runnable.run(agentId);
} finally {
- releaseResource(resourceKey, requiredResources);
+ releaseConcurrency(concurrencyKey, requiredConcurrency);
}
});
}
@@ -340,8 +340,8 @@ public class DefaultResourceAllocator implements ResourceAllocator, Serializable
@Override
public void execute() {
- synchronized (resourceUsages) {
- resourceUsagesCache.putAll(resourceUsages);
+ synchronized (concurrencyUsages) {
+ concurrencyUsagesCache.putAll(concurrencyUsages);
}
}
diff --git a/server-core/src/main/java/io/onedev/server/job/JobContext.java b/server-core/src/main/java/io/onedev/server/job/JobContext.java
index 4cfd746936..3e921680bd 100644
--- a/server-core/src/main/java/io/onedev/server/job/JobContext.java
+++ b/server-core/src/main/java/io/onedev/server/job/JobContext.java
@@ -9,6 +9,7 @@ import io.onedev.server.model.Project;
import io.onedev.server.model.support.administration.jobexecutor.JobExecutor;
import org.eclipse.jgit.lib.ObjectId;
+import javax.annotation.Nullable;
import java.io.Serializable;
import java.util.List;
@@ -19,7 +20,9 @@ public class JobContext implements Serializable {
private final String jobToken;
private final JobExecutor jobExecutor;
-
+
+ private final String sequentialGroup;
+
private final Long projectId;
private final String projectPath;
@@ -42,13 +45,13 @@ public class JobContext implements Serializable {
private volatile int retried;
- public JobContext(String jobToken, JobExecutor jobExecutor, Long projectId,
- String projectPath, String projectGitDir, Long buildId,
- Long buildNumber, List<Action> actions, String refName,
- ObjectId commitId, List<ServiceFacade> services,
- long timeout) {
+ public JobContext(String jobToken, JobExecutor jobExecutor, @Nullable String sequentialGroup,
+ Long projectId, String projectPath, String projectGitDir, Long buildId,
+ Long buildNumber, List<Action> actions, String refName, ObjectId commitId,
+ List<ServiceFacade> services, long timeout) {
this.jobToken = jobToken;
this.jobExecutor = jobExecutor;
+ this.sequentialGroup = sequentialGroup;
this.projectId = projectId;
this.projectPath = projectPath;
this.projectGitDir = projectGitDir;
@@ -69,6 +72,11 @@ public class JobContext implements Serializable {
return jobExecutor;
}
+ @Nullable
+ public String getSequentialGroup() {
+ return sequentialGroup;
+ }
+
public Long getBuildId() {
return buildId;
}
diff --git a/server-core/src/main/java/io/onedev/server/job/ResourceAllocator.java b/server-core/src/main/java/io/onedev/server/job/ResourceAllocator.java
index 10f4486a3e..301f3872a7 100644
--- a/server-core/src/main/java/io/onedev/server/job/ResourceAllocator.java
+++ b/server-core/src/main/java/io/onedev/server/job/ResourceAllocator.java
@@ -5,11 +5,11 @@ import io.onedev.server.search.entity.agent.AgentQuery;
public interface ResourceAllocator {
- boolean runServerJob(String resourceType, int totalResources, int requiredResources,
+ boolean runServerJob(String executorName, int totalConcurrency, int requiredConcurrency,
ClusterTask<Boolean> runnable);
- boolean runAgentJob(AgentQuery agentQuery, String resourceType, int totalResources,
- int requiredResources, AgentRunnable runnable);
+ boolean runAgentJob(AgentQuery agentQuery, String executorName, int totalConcurrency,
+ int requiredConcurrency, AgentRunnable runnable);
void agentDisconnecting(Long agentId);
diff --git a/server-core/src/main/java/io/onedev/server/model/Agent.java b/server-core/src/main/java/io/onedev/server/model/Agent.java
index c9e3e76067..e6e1361f80 100644
--- a/server-core/src/main/java/io/onedev/server/model/Agent.java
+++ b/server-core/src/main/java/io/onedev/server/model/Agent.java
@@ -98,7 +98,7 @@ public class Agent extends AbstractEntity {
@Column(nullable=false)
private String osArch;
- private int cpus;
+ private int cpuCount;
private boolean paused;
@@ -165,12 +165,12 @@ public class Agent extends AbstractEntity {
this.paused = paused;
}
- public int getCpus() {
- return cpus;
+ public int getCpuCount() {
+ return cpuCount;
}
- public void setCpus(int cpus) {
- this.cpus = cpus;
+ public void setCpuCount(int cpuCount) {
+ this.cpuCount = cpuCount;
}
public Collection<AgentAttribute> getAttributes() {
@@ -209,7 +209,7 @@ public class Agent extends AbstractEntity {
public AgentData getAgentData() {
return new AgentData(getToken().getValue(), new OsInfo(osName, osVersion, osArch),
- name, ipAddress, cpus, getAttributeMap());
+ name, ipAddress, cpuCount, getAttributeMap());
}
}
diff --git a/server-plugin/server-plugin-executor-remotedocker/src/main/java/io/onedev/server/plugin/executor/remotedocker/RemoteDockerExecutor.java b/server-plugin/server-plugin-executor-remotedocker/src/main/java/io/onedev/server/plugin/executor/remotedocker/RemoteDockerExecutor.java
index 5e5071d61d..ac47a61049 100644
--- a/server-plugin/server-plugin-executor-remotedocker/src/main/java/io/onedev/server/plugin/executor/remotedocker/RemoteDockerExecutor.java
+++ b/server-plugin/server-plugin-executor-remotedocker/src/main/java/io/onedev/server/plugin/executor/remotedocker/RemoteDockerExecutor.java
@@ -200,7 +200,7 @@ public class RemoteDockerExecutor extends ServerDockerExecutor {
}
}
};
-
+
getResourceAllocator().runAgentJob(
AgentQuery.parse(agentQuery, true), getName(),
getConcurrencyNumber(), 1, runnable);
diff --git a/server-plugin/server-plugin-executor-servershell/src/main/java/io/onedev/server/plugin/executor/servershell/ServerShellExecutor.java b/server-plugin/server-plugin-executor-servershell/src/main/java/io/onedev/server/plugin/executor/servershell/ServerShellExecutor.java
index f05e30d835..4635908cad 100644
--- a/server-plugin/server-plugin-executor-servershell/src/main/java/io/onedev/server/plugin/executor/servershell/ServerShellExecutor.java
+++ b/server-plugin/server-plugin-executor-servershell/src/main/java/io/onedev/server/plugin/executor/servershell/ServerShellExecutor.java
@@ -286,7 +286,8 @@ public class ServerShellExecutor extends JobExecutor implements Testable<TestDat
});
jobLogger.log("Pending resource allocation...");
- return getResourceAllocator().runServerJob(getName(), getConcurrencyNumber(), 1, runnable);
+ return getResourceAllocator().runServerJob(getName(), getConcurrencyNumber(),
+ 1, runnable);
}
@Override