onedev/agent

Fix issue onedev/server#518 - Build docker image step runs slowly on Windows
Robin Shen committed 2 years ago

525ca84e

1 parent 092b4406
Release

Total 5 files Show one by one

■ ■ ■ ■ ■ ■

pom.xml

		skipped 9 lines
10	10		<version>1.0.5</version>
11	11		</parent>
12	12		<artifactId>agent</artifactId>
13		-	<version>1.2.0</version>
	13	+	<version>1.2.1</version>
14	14		<build>
15	15		<plugins>
16	16		<plugin>
		skipped 128 lines
145	145		</dependency>
146	146		</dependencies>
147	147		<properties>
148		-	<k8shelper.version>2.5.0</k8shelper.version>
	148	+	<k8shelper.version>2.5.1</k8shelper.version>
149	149		<jackson.version>2.12.1</jackson.version>
150	150		<jersey.version>2.26</jersey.version>
151	151		<bootstrap>true</bootstrap>
		skipped 4 lines

■ ■ ■ ■ ■ ■

src/main/java/io/onedev/agent/AgentSocket.java

		skipped 79 lines
80	80		import io.onedev.commons.utils.command.Commandline;
81	81		import io.onedev.commons.utils.command.ExecutionResult;
82	82		import io.onedev.commons.utils.command.LineConsumer;
	83	+	import io.onedev.k8shelper.BuildImageFacade;
83	84		import io.onedev.k8shelper.CacheAllocationRequest;
84	85		import io.onedev.k8shelper.CacheInstance;
85		-	import io.onedev.k8shelper.CheckoutExecutable;
	86	+	import io.onedev.k8shelper.CheckoutFacade;
86	87		import io.onedev.k8shelper.CloneInfo;
87		-	import io.onedev.k8shelper.CommandExecutable;
88		-	import io.onedev.k8shelper.CompositeExecutable;
89		-	import io.onedev.k8shelper.ContainerExecutable;
	88	+	import io.onedev.k8shelper.CommandFacade;
	89	+	import io.onedev.k8shelper.CompositeFacade;
	90	+	import io.onedev.k8shelper.RunContainerFacade;
90	91		import io.onedev.k8shelper.KubernetesHelper;
91		-	import io.onedev.k8shelper.LeafExecutable;
	92	+	import io.onedev.k8shelper.LeafFacade;
92	93		import io.onedev.k8shelper.LeafHandler;
93	94		import io.onedev.k8shelper.OsContainer;
94	95		import io.onedev.k8shelper.OsExecution;
95		-	import io.onedev.k8shelper.ServerExecutable;
	96	+	import io.onedev.k8shelper.ServerSideFacade;
96	97
97	98		@WebSocket
98	99		public class AgentSocket implements Runnable {
		skipped 216 lines
315	316		String messageData = jobData.getJobToken() + ":" + workspaceDir.getAbsolutePath();
316	317		new Message(MessageType.REPORT_JOB_WORKSPACE, messageData).sendBy(session);
317	318
318		-	CompositeExecutable entryExecutable = new CompositeExecutable(jobData.getActions());
319		-	boolean successful = entryExecutable.execute(new LeafHandler() {
	319	+	CompositeFacade entryFacade = new CompositeFacade(jobData.getActions());
	320	+	boolean successful = entryFacade.execute(new LeafHandler() {
320	321
321	322		@Override
322		-	public boolean execute(LeafExecutable executable, List<Integer> position) {
323		-	String stepNames = entryExecutable.getNamesAsString(position);
	323	+	public boolean execute(LeafFacade facade, List<Integer> position) {
	324	+	String stepNames = entryFacade.getNamesAsString(position);
324	325		jobLogger.notice("Running step \"" + stepNames + "\"...");
325	326
326		-	if (executable instanceof CommandExecutable) {
327		-	CommandExecutable commandExecutable = (CommandExecutable) executable;
328		-	OsExecution execution = commandExecutable.getExecution(Agent.osInfo);
	327	+	if (facade instanceof CommandFacade) {
	328	+	CommandFacade commandFacade = (CommandFacade) facade;
	329	+	OsExecution execution = commandFacade.getExecution(Agent.osInfo);
329	330		if (execution.getImage() != null) {
330	331		throw new ExplicitException("This step can only be executed by server docker executor, "
331	332		+ "remote docker executor, or kubernetes executor");
332	333		}
333	334
334		-	File jobScriptFile = new File(buildDir, "job-commands" + commandExecutable.getScriptExtension());
	335	+	File jobScriptFile = new File(buildDir, "job-commands" + commandFacade.getScriptExtension());
335	336		try {
336	337		FileUtils.writeLines(
337	338		jobScriptFile,
338	339		new ArrayList<>(replacePlaceholders(execution.getCommands(), buildDir)),
339		-	commandExecutable.getEndOfLine());
	340	+	commandFacade.getEndOfLine());
340	341		} catch (IOException e) {
341	342		throw new RuntimeException(e);
342	343		}
		skipped 16 lines
359	360		}
360	361		}
361	362
362		-	Commandline interpreter = commandExecutable.getInterpreter();
	363	+	Commandline interpreter = commandFacade.getInterpreter();
363	364		Map<String, String> environments = new HashMap<>();
364	365		environments.put("GIT_HOME", userDir.getAbsolutePath());
365	366		interpreter.workingDir(workspaceDir).environments(environments);
366	367		interpreter.addArgs(jobScriptFile.getAbsolutePath());
367	368
368	369		ExecutionResult result = interpreter.execute(
369		-	ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newErrorLogger(jobLogger));
	370	+	ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newWarningLogger(jobLogger));
370	371		if (result.getReturnCode() != 0) {
371	372		jobLogger.error("Step \"" + stepNames + "\" is failed: Command exited with code " + result.getReturnCode());
372	373		return false;
373	374		}
374		-	} else if (executable instanceof ContainerExecutable) {
	375	+	} else if (facade instanceof BuildImageFacade \|\| facade instanceof RunContainerFacade) {
375	376		throw new ExplicitException("This step can only be executed by server docker executor, "
376	377		+ "remote docker executor, or kubernetes executor");
377		-	} else if (executable instanceof CheckoutExecutable) {
	378	+	} else if (facade instanceof CheckoutFacade) {
378	379		try {
379		-	CheckoutExecutable checkoutExecutable = (CheckoutExecutable) executable;
	380	+	CheckoutFacade checkoutFacade = (CheckoutFacade) facade;
380	381		jobLogger.log("Checking out code...");
381	382		Commandline git = new Commandline(Agent.gitPath);
382	383		git.workingDir(workspaceDir);
		skipped 1 lines
384	385		environments.put("HOME", userDir.getAbsolutePath());
385	386		git.environments(environments);
386	387
387		-	CloneInfo cloneInfo = checkoutExecutable.getCloneInfo();
	388	+	CloneInfo cloneInfo = checkoutFacade.getCloneInfo();
388	389
389	390		cloneInfo.writeAuthData(userDir, git,
390	391		ExecutorUtils.newInfoLogger(jobLogger),
391		-	ExecutorUtils.newErrorLogger(jobLogger));
	392	+	ExecutorUtils.newWarningLogger(jobLogger));
392	393
393	394		List<String> trustCertContent = jobData.getTrustCertContent();
394	395		if (!trustCertContent.isEmpty()) {
395	396		installGitCert(new File(userDir, "trust-cert.pem"), trustCertContent, git,
396		-	ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newErrorLogger(jobLogger));
	397	+	ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newWarningLogger(jobLogger));
397	398		}
398	399
399		-	int cloneDepth = checkoutExecutable.getCloneDepth();
	400	+	int cloneDepth = checkoutFacade.getCloneDepth();
400	401
401	402		cloneRepository(git, cloneInfo.getCloneUrl(), cloneInfo.getCloneUrl(),
402		-	jobData.getCommitHash(), checkoutExecutable.isWithLfs(),
403		-	checkoutExecutable.isWithSubmodules(), cloneDepth,
404		-	ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newErrorLogger(jobLogger));
	403	+	jobData.getCommitHash(), checkoutFacade.isWithLfs(),
	404	+	checkoutFacade.isWithSubmodules(), cloneDepth,
	405	+	ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newWarningLogger(jobLogger));
405	406		} catch (Exception e) {
406	407		jobLogger.error("Step \"" + stepNames + "\" is failed: " + getErrorMessage(e));
407	408		return false;
408	409		}
409	410		} else {
410		-	ServerExecutable serverExecutable = (ServerExecutable) executable;
	411	+	ServerSideFacade serverSideFacade = (ServerSideFacade) facade;
411	412
412	413		try {
413		-	KubernetesHelper.runServerStep(Agent.serverUrl, jobData.getJobToken(), position,
414		-	serverExecutable.getIncludeFiles(), serverExecutable.getExcludeFiles(),
415		-	serverExecutable.getPlaceholders(), buildDir, workspaceDir, jobLogger);
	414	+	KubernetesHelper.runServerSideStep(Agent.serverUrl, jobData.getJobToken(), position,
	415	+	serverSideFacade.getIncludeFiles(), serverSideFacade.getExcludeFiles(),
	416	+	serverSideFacade.getPlaceholders(), buildDir, workspaceDir, jobLogger);
416	417		} catch (Exception e) {
417	418		jobLogger.error("Step \"" + stepNames + "\" is failed: " + getErrorMessage(e));
418	419		return false;
		skipped 4 lines
423	424		}
424	425
425	426		@Override
426		-	public void skip(LeafExecutable executable, List<Integer> position) {
427		-	jobLogger.notice("Step \"" + entryExecutable.getNamesAsString(position) + "\" is skipped");
	427	+	public void skip(LeafFacade facade, List<Integer> position) {
	428	+	jobLogger.notice("Step \"" + entryFacade.getNamesAsString(position) + "\" is skipped");
428	429		}
429	430
430	431		}, new ArrayList<>());
		skipped 98 lines
529	530		String messageData = jobData.getJobToken() + ":" + containerWorkspace;
530	531		new Message(MessageType.REPORT_JOB_WORKSPACE, messageData).sendBy(session);
531	532
532		-	CompositeExecutable entryExecutable = new CompositeExecutable(jobData.getActions());
	533	+	CompositeFacade entryFacade = new CompositeFacade(jobData.getActions());
533	534
534		-	boolean successful = entryExecutable.execute(new LeafHandler() {
	535	+	boolean successful = entryFacade.execute(new LeafHandler() {
535	536
536	537		private int runStepContainer(String image, @Nullable String entrypoint,
537	538		List<String> arguments, Map<String, String> environments,
		skipped 54 lines
592	593		docker.addArgs(arguments.toArray(new String[arguments.size()]));
593	594
594	595		ExecutionResult result = docker.execute(
595		-	ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newErrorLogger(jobLogger),
	596	+	ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newWarningLogger(jobLogger),
596	597		null, newDockerKiller(new Commandline(Agent.dockerPath), containerName, jobLogger));
597	598		return result.getReturnCode();
598	599		}
599	600
600	601		@Override
601		-	public boolean execute(LeafExecutable executable, List<Integer> position) {
602		-	String stepNames = entryExecutable.getNamesAsString(position);
	602	+	public boolean execute(LeafFacade facade, List<Integer> position) {
	603	+	String stepNames = entryFacade.getNamesAsString(position);
603	604		jobLogger.notice("Running step \"" + stepNames + "\"...");
604	605
605		-	if (executable instanceof CommandExecutable) {
606		-	CommandExecutable commandExecutable = (CommandExecutable) executable;
607		-	OsExecution execution = commandExecutable.getExecution(Agent.osInfo);
	606	+	if (facade instanceof CommandFacade) {
	607	+	CommandFacade commandFacade = (CommandFacade) facade;
	608	+	OsExecution execution = commandFacade.getExecution(Agent.osInfo);
608	609		if (execution.getImage() == null) {
609	610		throw new ExplicitException("This step can only be executed by server shell "
610	611		+ "executor or remote shell executor");
611	612		}
612	613
613		-	Commandline entrypoint = getEntrypoint(hostBuildHome, commandExecutable,
	614	+	Commandline entrypoint = getEntrypoint(hostBuildHome, commandFacade,
614	615		Agent.osInfo, hostAuthInfoHome.get() != null);
615	616		int exitCode = runStepContainer(execution.getImage(), entrypoint.executable(),
616		-	entrypoint.arguments(), new HashMap<>(), null, position, commandExecutable.isUseTTY());
	617	+	entrypoint.arguments(), new HashMap<>(), null, position, commandFacade.isUseTTY());
617	618
618	619		if (exitCode != 0) {
619	620		jobLogger.error("Step \"" + stepNames + "\" is failed: Command exited with code " + exitCode);
620	621		return false;
621	622		}
622		-	} else if (executable instanceof ContainerExecutable) {
623		-	ContainerExecutable containerExecutable = (ContainerExecutable) executable;
	623	+	} else if (facade instanceof BuildImageFacade) {
	624	+	DockerExecutorUtils.buildImage(new Commandline(
	625	+	Agent.dockerPath), (BuildImageFacade) facade, hostWorkspace, jobLogger);
	626	+	} else if (facade instanceof RunContainerFacade) {
	627	+	RunContainerFacade runContainerFacade = (RunContainerFacade) facade;
624	628
625		-	OsContainer container = containerExecutable.getContainer(Agent.osInfo);
	629	+	OsContainer container = runContainerFacade.getContainer(Agent.osInfo);
626	630		List<String> arguments = new ArrayList<>();
627	631		if (container.getArgs() != null)
628	632		arguments.addAll(Arrays.asList(StringUtils.parseQuoteTokens(container.getArgs())));
629	633		int exitCode = runStepContainer(container.getImage(), null, arguments,
630	634		container.getEnvMap(), container.getWorkingDir(),
631		-	position, containerExecutable.isUseTTY());
	635	+	position, runContainerFacade.isUseTTY());
632	636		if (exitCode != 0) {
633	637		jobLogger.error("Step \"" + stepNames + "\" is failed: Container exit with code " + exitCode);
634	638		return false;
635	639		}
636		-	} else if (executable instanceof CheckoutExecutable) {
	640	+	} else if (facade instanceof CheckoutFacade) {
637	641		try {
638		-	CheckoutExecutable checkoutExecutable = (CheckoutExecutable) executable;
	642	+	CheckoutFacade checkoutFacade = (CheckoutFacade) facade;
639	643		jobLogger.log("Checking out code...");
640	644
641	645		if (hostAuthInfoHome.get() == null)
		skipped 2 lines
644	648		Commandline git = new Commandline(Agent.gitPath);
645	649		git.workingDir(hostWorkspace).environments().put("HOME", hostAuthInfoHome.get().getAbsolutePath());
646	650
647		-	CloneInfo cloneInfo = checkoutExecutable.getCloneInfo();
	651	+	CloneInfo cloneInfo = checkoutFacade.getCloneInfo();
648	652
649	653		cloneInfo.writeAuthData(hostAuthInfoHome.get(), git,
650		-	ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newErrorLogger(jobLogger));
	654	+	ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newWarningLogger(jobLogger));
651	655		try {
652	656		List<String> trustCertContent = jobData.getTrustCertContent();
653	657		if (!trustCertContent.isEmpty()) {
654	658		installGitCert(new File(hostAuthInfoHome.get(), "trust-cert.pem"), trustCertContent, git,
655		-	ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newErrorLogger(jobLogger));
	659	+	ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newWarningLogger(jobLogger));
656	660		}
657	661
658		-	int cloneDepth = checkoutExecutable.getCloneDepth();
	662	+	int cloneDepth = checkoutFacade.getCloneDepth();
659	663
660		-	String cloneUrl = checkoutExecutable.getCloneInfo().getCloneUrl();
	664	+	String cloneUrl = checkoutFacade.getCloneInfo().getCloneUrl();
661	665		String commitHash = jobData.getCommitHash();
662	666		cloneRepository(git, cloneUrl, cloneUrl, commitHash,
663		-	checkoutExecutable.isWithLfs(), checkoutExecutable.isWithSubmodules(), cloneDepth,
664		-	ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newErrorLogger(jobLogger));
	667	+	checkoutFacade.isWithLfs(), checkoutFacade.isWithSubmodules(), cloneDepth,
	668	+	ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newWarningLogger(jobLogger));
665	669		} finally {
666	670		git.clearArgs();
667	671		git.addArgs("config", "--global", "--unset", "core.sshCommand");
668		-	ExecutionResult result = git.execute(ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newErrorLogger(jobLogger));
	672	+	ExecutionResult result = git.execute(ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newWarningLogger(jobLogger));
669	673		if (result.getReturnCode() != 5 && result.getReturnCode() != 0)
670	674		result.checkReturnCode();
671	675		}
		skipped 2 lines
674	678		return false;
675	679		}
676	680		} else {
677		-	ServerExecutable serverExecutable = (ServerExecutable) executable;
	681	+	ServerSideFacade serverSideFacade = (ServerSideFacade) facade;
678	682
679	683		try {
680		-	KubernetesHelper.runServerStep(Agent.serverUrl, jobData.getJobToken(), position,
681		-	serverExecutable.getIncludeFiles(), serverExecutable.getExcludeFiles(),
682		-	serverExecutable.getPlaceholders(), hostBuildHome, hostWorkspace, jobLogger);
	684	+	KubernetesHelper.runServerSideStep(Agent.serverUrl, jobData.getJobToken(), position,
	685	+	serverSideFacade.getIncludeFiles(), serverSideFacade.getExcludeFiles(),
	686	+	serverSideFacade.getPlaceholders(), hostBuildHome, hostWorkspace, jobLogger);
683	687		} catch (Exception e) {
684	688		jobLogger.error("Step \"" + stepNames + "\" is failed: " + getErrorMessage(e));
685	689		return false;
		skipped 4 lines
690	694		}
691	695
692	696		@Override
693		-	public void skip(LeafExecutable executable, List<Integer> position) {
694		-	jobLogger.notice("Step \"" + entryExecutable.getNamesAsString(position) + "\" is skipped");
	697	+	public void skip(LeafFacade facade, List<Integer> position) {
	698	+	jobLogger.notice("Step \"" + entryFacade.getNamesAsString(position) + "\" is skipped");
695	699		}
696	700
697	701		}, new ArrayList<>());
		skipped 232 lines

■ ■ ■ ■ ■ ■

src/main/java/io/onedev/agent/DockerExecutorUtils.java

		skipped 32 lines
33	33		import io.onedev.commons.utils.command.ExecutionResult;
34	34		import io.onedev.commons.utils.command.LineConsumer;
35	35		import io.onedev.commons.utils.command.ProcessKiller;
36		-	import io.onedev.k8shelper.CommandExecutable;
	36	+	import io.onedev.k8shelper.BuildImageFacade;
	37	+	import io.onedev.k8shelper.CommandFacade;
37	38		import io.onedev.k8shelper.OsExecution;
38	39		import io.onedev.k8shelper.OsInfo;
39	40
40		-	public class DockerExecutorUtils {
	41	+	public class DockerExecutorUtils extends ExecutorUtils {
41	42
42	43		private static final Logger logger = LoggerFactory.getLogger(DockerExecutorUtils.class);
43	44
		skipped 5 lines
49	50		return explicitException.getMessage();
50	51		}
51	52
	53	+	public static void buildImage(Commandline docker, BuildImageFacade buildImageFacade,
	54	+	File workspace, TaskLogger jobLogger) {
	55	+	String[] parsedTags = StringUtils.parseQuoteTokens(buildImageFacade.getTags());
	56	+
	57	+	docker.clearArgs();
	58	+	docker.addArgs("build");
	59	+
	60	+	for (String tag: parsedTags)
	61	+	docker.addArgs("-t", tag);
	62	+	docker.addArgs("-f", buildImageFacade.getDockerfile());
	63	+	if (buildImageFacade.getBuildPath() != null)
	64	+	docker.addArgs(buildImageFacade.getBuildPath());
	65	+	else
	66	+	docker.addArgs(".");
	67	+
	68	+	docker.workingDir(workspace);
	69	+	docker.execute(newInfoLogger(jobLogger), newWarningLogger(jobLogger)).checkReturnCode();
	70	+
	71	+	if (buildImageFacade.isPublish()) {
	72	+	for (String tag: parsedTags) {
	73	+	docker.clearArgs();
	74	+	docker.addArgs("push", tag);
	75	+	docker.execute(newInfoLogger(jobLogger), newWarningLogger(jobLogger)).checkReturnCode();
	76	+	}
	77	+	}
	78	+	}
	79	+
52	80		public static ProcessKiller newDockerKiller(Commandline docker, String containerName, TaskLogger jobLogger) {
53	81		return new ProcessKiller() {
54	82
		skipped 22 lines
77	105		};
78	106		}
79	107
80		-	public static Commandline getEntrypoint(File hostBuildHome, CommandExecutable commandExecutable,
	108	+	public static Commandline getEntrypoint(File hostBuildHome, CommandFacade commandFacade,
81	109		OsInfo osInfo, boolean withHostAuthInfo) {
82		-	Commandline interpreter = commandExecutable.getInterpreter();
	110	+	Commandline interpreter = commandFacade.getInterpreter();
83	111		String entrypointExecutable;
84	112		String[] entrypointArgs;
85	113
86		-	File scriptFile = new File(hostBuildHome, "job-commands" + commandExecutable.getScriptExtension());
	114	+	File scriptFile = new File(hostBuildHome, "job-commands" + commandFacade.getScriptExtension());
87	115		try {
88		-	OsExecution execution = commandExecutable.getExecution(osInfo);
	116	+	OsExecution execution = commandFacade.getExecution(osInfo);
89	117		FileUtils.writeLines(
90	118		scriptFile,
91	119		new ArrayList<>(replacePlaceholders(execution.getCommands(), hostBuildHome)),
92		-	commandExecutable.getEndOfLine());
	120	+	commandFacade.getEndOfLine());
93	121		} catch (IOException e) {
94	122		throw new RuntimeException(e);
95	123		}
		skipped 425 lines

■ ■ ■ ■ ■ ■ ■

src/main/java/io/onedev/agent/ExecutorUtils.java

		skipped 31 lines
32	32		};
33	33		}
34	34
	35	+	public static LineConsumer newWarningLogger(TaskLogger jobLogger) {
	36	+	return new LineConsumer(StandardCharsets.UTF_8.name()) {
	37	+
	38	+	@Override
	39	+	public void consume(String line) {
	40	+	jobLogger.warning(line);
	41	+	}
	42	+
	43	+	};
	44	+	}
	45	+
35	46		public static LineConsumer newErrorLogger(TaskLogger jobLogger) {
36	47		return new LineConsumer(StandardCharsets.UTF_8.name()) {
37	48
38	49		@Override
39	50		public void consume(String line) {
40		-	jobLogger.warning(line);
	51	+	jobLogger.error(line);
41	52		}
42	53
43	54		};
		skipped 41 lines

■ ■ ■ ■ ■ ■

src/main/java/io/onedev/agent/ShellExecutorUtils.java

		skipped 7 lines
8	8		import io.onedev.commons.utils.FileUtils;
9	9		import io.onedev.commons.utils.TaskLogger;
10	10		import io.onedev.commons.utils.command.Commandline;
11		-	import io.onedev.k8shelper.CommandExecutable;
	11	+	import io.onedev.k8shelper.CommandFacade;
12	12		import io.onedev.k8shelper.KubernetesHelper;
13	13
14	14		public class ShellExecutorUtils {
		skipped 7 lines
22	22		}
23	23
24	24		public static void testCommands(Commandline git, List<String> commands, TaskLogger jobLogger) {
25		-	CommandExecutable executable = new CommandExecutable(null, commands, true);
	25	+	CommandFacade executable = new CommandFacade(null, commands, true);
26	26		Commandline interpreter = executable.getInterpreter();
27	27		File buildDir = FileUtils.createTempDir("onedev-build");
28	28		try {
		skipped 4 lines
33	33		File workspaceDir = new File(buildDir, "workspace");
34	34		FileUtils.createDir(workspaceDir);
35	35		interpreter.workingDir(workspaceDir).addArgs(jobScriptFile.getAbsolutePath());
36		-	interpreter.execute(ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newErrorLogger(jobLogger)).checkReturnCode();
	36	+	interpreter.execute(ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newWarningLogger(jobLogger)).checkReturnCode();
37	37
38	38		KubernetesHelper.testGitLfsAvailability(git, jobLogger);
39	39		} catch (IOException e) {
		skipped 8 lines

Fix issue onedev/server#518 - Build docker image step runs slowly on Windows