onedev/server

■ ■ ■ ■ ■ ■

pom.xml

		skipped 563 lines
564	564		</repositories>
565	565		<properties>
566	566		<commons.version>2.0.20</commons.version>
567		-	<agent.version>1.2.0</agent.version>
	567	+	<agent.version>1.2.1</agent.version>
568	568		<slf4j.version>1.7.30</slf4j.version>
569	569		<logback.version>1.2.0</logback.version>
570	570		<antlr.version>4.7.2</antlr.version>
		skipped 15 lines

■ ■ ■ ■ ■ ■

server-core/src/main/java/io/onedev/server/buildspec/BuildSpec.java

		skipped 1270 lines
1271	1271		}
1272	1272		}
1273	1273
	1274	+	private void migrate15_steps(SequenceNode stepsNode) {
	1275	+	for (Node stepsNodeItem: stepsNode.getValue()) {
	1276	+	MappingNode stepNode = (MappingNode) stepsNodeItem;
	1277	+	if (stepNode.getTag().getValue().equals("!BuildImageStep")) {
	1278	+	for (Iterator<NodeTuple> itStepNodeTuple = stepNode.getValue().iterator(); itStepNodeTuple.hasNext();) {
	1279	+	NodeTuple stepNodeTuple = itStepNodeTuple.next();
	1280	+	String key = ((ScalarNode)stepNodeTuple.getKeyNode()).getValue();
	1281	+	if (key.equals("useTTY") \|\| key.equals("login"))
	1282	+	itStepNodeTuple.remove();
	1283	+	}
	1284	+	}
	1285	+	}
	1286	+	}
	1287	+
	1288	+	@SuppressWarnings("unused")
	1289	+	private void migrate15(VersionedYamlDoc doc, Stack<Integer> versions) {
	1290	+	for (NodeTuple specTuple: doc.getValue()) {
	1291	+	String specObjectKey = ((ScalarNode)specTuple.getKeyNode()).getValue();
	1292	+	if (specObjectKey.equals("jobs")) {
	1293	+	SequenceNode jobsNode = (SequenceNode) specTuple.getValueNode();
	1294	+	for (Node jobsNodeItem: jobsNode.getValue()) {
	1295	+	MappingNode jobNode = (MappingNode) jobsNodeItem;
	1296	+	for (NodeTuple jobTuple: jobNode.getValue()) {
	1297	+	String jobTupleKey = ((ScalarNode)jobTuple.getKeyNode()).getValue();
	1298	+	if (jobTupleKey.equals("steps"))
	1299	+	migrate15_steps((SequenceNode) jobTuple.getValueNode());
	1300	+	}
	1301	+	}
	1302	+	} else if (specObjectKey.equals("stepTemplates")) {
	1303	+	SequenceNode stepTemplatesNode = (SequenceNode) specTuple.getValueNode();
	1304	+	for (Node stepTemplatesNodeItem: stepTemplatesNode.getValue()) {
	1305	+	MappingNode stepTemplateNode = (MappingNode) stepTemplatesNodeItem;
	1306	+	for (NodeTuple stepTemplateTuple: stepTemplateNode.getValue()) {
	1307	+	String stepTemplateTupleKey = ((ScalarNode)stepTemplateTuple.getKeyNode()).getValue();
	1308	+	if (stepTemplateTupleKey.equals("steps"))
	1309	+	migrate15_steps((SequenceNode) stepTemplateTuple.getValueNode());
	1310	+	}
	1311	+	}
	1312	+	}
	1313	+	}
	1314	+	}
	1315	+
1274	1316		}
1275	1317

■ ■ ■ ■ ■ ■

server-core/src/main/java/io/onedev/server/buildspec/job/DefaultJobManager.java

		skipped 56 lines
57	57		import io.onedev.commons.utils.TaskLogger;
58	58		import io.onedev.k8shelper.Action;
59	59		import io.onedev.k8shelper.CacheInstance;
60		-	import io.onedev.k8shelper.CompositeExecutable;
61		-	import io.onedev.k8shelper.Executable;
62		-	import io.onedev.k8shelper.LeafExecutable;
	60	+	import io.onedev.k8shelper.CompositeFacade;
	61	+	import io.onedev.k8shelper.StepFacade;
	62	+	import io.onedev.k8shelper.LeafFacade;
63	63		import io.onedev.k8shelper.LeafVisitor;
64		-	import io.onedev.k8shelper.ServerExecutable;
	64	+	import io.onedev.k8shelper.ServerSideFacade;
65	65		import io.onedev.server.OneDev;
66	66		import io.onedev.server.buildspec.BuildSpec;
67	67		import io.onedev.server.buildspec.Service;
		skipped 6 lines
74	74		import io.onedev.server.buildspec.param.ParamUtils;
75	75		import io.onedev.server.buildspec.param.spec.ParamSpec;
76	76		import io.onedev.server.buildspec.param.spec.SecretParam;
77		-	import io.onedev.server.buildspec.step.ServerStep;
	77	+	import io.onedev.server.buildspec.step.ServerSideStep;
78	78		import io.onedev.server.buildspec.step.Step;
79	79		import io.onedev.server.entitymanager.AgentManager;
80	80		import io.onedev.server.entitymanager.BuildManager;
		skipped 524 lines
605	605
606	606		@Override
607	607		public Map<String, byte[]> call() {
608		-	Executable entryExecutable = new CompositeExecutable(getActions());
	608	+	StepFacade entryExecutable = new CompositeFacade(getActions());
609	609
610		-	LeafVisitor<LeafExecutable> visitor = new LeafVisitor<LeafExecutable>() {
	610	+	LeafVisitor<LeafFacade> visitor = new LeafVisitor<LeafFacade>() {
611	611
612	612		@Override
613		-	public LeafExecutable visit(LeafExecutable executable, List<Integer> position) {
	613	+	public LeafFacade visit(LeafFacade executable, List<Integer> position) {
614	614		if (position.equals(stepPosition))
615	615		return executable;
616	616		else
		skipped 2 lines
619	619
620	620		};
621	621
622		-	ServerExecutable serverExecutable = (ServerExecutable) entryExecutable.traverse(visitor, new ArrayList<>());
623		-	ServerStep serverStep = (ServerStep) serverExecutable.getStep();
	622	+	ServerSideFacade serverExecutable = (ServerSideFacade) entryExecutable.traverse(visitor, new ArrayList<>());
	623	+	ServerSideStep serverStep = (ServerSideStep) serverExecutable.getStep();
624	624
625	625		serverStep = new EditableStringTransformer(new Function<String, String>() {
626	626
		skipped 727 lines

■ ■ ■ ■ ■ ■

server-core/src/main/java/io/onedev/server/buildspec/step/BuildImageStep.java

1	1		package io.onedev.server.buildspec.step;
2	2
3		-	import java.util.ArrayList;
4	3		import java.util.List;
5		-	import java.util.Map;
6	4
7	5		import org.hibernate.validator.constraints.NotEmpty;
8	6
9	7		import io.onedev.commons.codeassist.InputSuggestion;
10		-	import io.onedev.commons.utils.StringUtils;
11		-	import io.onedev.k8shelper.CommandExecutable;
12		-	import io.onedev.k8shelper.Executable;
13		-	import io.onedev.k8shelper.KubernetesHelper;
14		-	import io.onedev.k8shelper.OsExecution;
15		-	import io.onedev.k8shelper.OsInfo;
16		-	import io.onedev.k8shelper.OsMatcher;
	8	+	import io.onedev.k8shelper.BuildImageFacade;
	9	+	import io.onedev.k8shelper.StepFacade;
17	10		import io.onedev.server.buildspec.BuildSpec;
18	11		import io.onedev.server.buildspec.param.ParamCombination;
19	12		import io.onedev.server.model.Build;
20		-	import io.onedev.server.model.support.RegistryLogin;
21	13		import io.onedev.server.web.editable.annotation.Editable;
22	14		import io.onedev.server.web.editable.annotation.Interpolative;
23	15
		skipped 8 lines
32	24
33	25		private String tags;
34	26
35		-	private RegistryLogin login;
36		-
37	27		private boolean publish;
38		-
39		-	private boolean useTTY;
40	28
41	29		@Editable(order=100, description="Optionally specify build path relative to <a href='$docRoot/pages/concepts.md#job-workspace' target='_blank'>job workspace</a>. "
42	30		+ "Leave empty to use job workspace itself")
		skipped 28 lines
71	59		this.tags = tags;
72	60		}
73	61
74		-	@Editable(order=350, name="Registry Login", description="Optionally specify docker registry login")
75		-	public RegistryLogin getLogin() {
76		-	return login;
77		-	}
78		-
79		-	public void setLogin(RegistryLogin login) {
80		-	this.login = login;
81		-	}
82		-
83	62		@Editable(order=400, name="Publish After Build", description="Whether or not to publish built image to docker registry")
84	63		public boolean isPublish() {
85	64		return publish;
		skipped 3 lines
89	68		this.publish = publish;
90	69		}
91	70
92		-	@Editable(order=10000, name="Enable TTY Mode", description=CommandStep.USE_TTY_HELP)
93		-	public boolean isUseTTY() {
94		-	return useTTY;
95		-	}
96		-
97		-	public void setUseTTY(boolean useTTY) {
98		-	this.useTTY = useTTY;
99		-	}
100		-
101	71		static List<InputSuggestion> suggestVariables(String matchWith) {
102	72		return BuildSpec.suggestVariables(matchWith, false, false);
103	73		}
104	74
105		-	private List<String> getNonWindowsCommands() {
106		-	List<String> commands = new ArrayList<>();
107		-
108		-	StringBuilder buildCommand = new StringBuilder("docker build ");
109		-	String[] parsedTags = StringUtils.parseQuoteTokens(getTags());
110		-	for (String tag: parsedTags)
111		-	buildCommand.append("-t ").append(tag).append(" ");
112		-	if (getDockerfile() != null)
113		-	buildCommand.append("-f ").append("$workspace/" + getDockerfile());
114		-	else
115		-	buildCommand.append("-f ").append("$workspace/Dockerfile");
116		-
117		-	buildCommand.append(" ");
118		-
119		-	if (getBuildPath() != null)
120		-	buildCommand.append("$workspace/" + getBuildPath());
121		-	else
122		-	buildCommand.append("$workspace");
123		-
124		-	commands.add("set -e");
125		-
126		-	if (getLogin() != null) {
127		-	StringBuilder loginCommand = new StringBuilder("echo ");
128		-	loginCommand.append(getLogin().getPassword()).append("\|docker login -u ");
129		-	loginCommand.append(getLogin().getUserName()).append(" --password-stdin");
130		-	if (getLogin().getRegistryUrl() != null)
131		-	loginCommand.append(" ").append(getLogin().getRegistryUrl());
132		-	commands.add(loginCommand.toString());
133		-	}
134		-
135		-	commands.add("workspace=$(pwd)");
136		-	commands.add(buildCommand.toString());
137		-
138		-	if (isPublish()) {
139		-	for (String tag: parsedTags)
140		-	commands.add("docker push " + tag);
141		-	}
142		-
143		-	return commands;
144		-	}
145		-
146		-	private List<String> getWindowsCommands() {
147		-	List<String> commands = new ArrayList<>();
148		-
149		-	StringBuilder buildCommand = new StringBuilder("docker build ");
150		-	String[] parsedTags = StringUtils.parseQuoteTokens(getTags());
151		-	for (String tag: parsedTags)
152		-	buildCommand.append("-t ").append(tag).append(" ");
153		-	if (getDockerfile() != null)
154		-	buildCommand.append("-f ").append("%workspace%\\" + getDockerfile().replace('/', '\\'));
155		-	else
156		-	buildCommand.append("-f ").append("%workspace%\\Dockerfile");
157		-
158		-	buildCommand.append(" ");
159		-
160		-	if (getBuildPath() != null)
161		-	buildCommand.append("%workspace%\\" + getBuildPath().replace('/', '\\'));
162		-	else
163		-	buildCommand.append("%workspace%");
164		-
165		-	buildCommand.append(" \|\| exit /b 1");
166		-
167		-	commands.add("@echo off");
168		-
169		-	if (getLogin() != null) {
170		-	StringBuilder loginCommand = new StringBuilder("echo ");
171		-	loginCommand.append(getLogin().getPassword()).append("\|docker login -u ");
172		-	loginCommand.append(getLogin().getUserName()).append(" --password-stdin \|\| exit /b 1");
173		-	if (getLogin().getRegistryUrl() != null)
174		-	loginCommand.append(" ").append(getLogin().getRegistryUrl());
175		-	commands.add(loginCommand.toString());
176		-	}
177		-
178		-	commands.add("set workspace=%cd%");
179		-	commands.add(buildCommand.toString());
180		-
181		-	if (isPublish()) {
182		-	for (String tag: parsedTags)
183		-	commands.add("docker push " + tag + " \|\| exit /b 1");
184		-	}
185		-
186		-	return commands;
187		-	}
188		-
189	75		@Override
190		-	public Executable getExecutable(Build build, String jobToken, ParamCombination paramCombination) {
191		-	List<OsExecution> executions = new ArrayList<>();
192		-	String imageVersion = KubernetesHelper.getVersion();
193		-
194		-	String image = "1dev/docker-cli-alpine:1.0.0";
195		-	executions.add(new OsExecution(OsMatcher.NON_WINDOWS, image, getNonWindowsCommands()));
196		-
197		-	List<String> commands = getWindowsCommands();
198		-	for (Map.Entry<Integer, String> entry: OsInfo.WINDOWS_VERSIONS.entrySet()) {
199		-	OsMatcher osMatcher = new OsMatcher("(?i).windows.", ".\\." + entry.getKey(), ".");
200		-	image = KubernetesHelper.IMAGE_REPO_PREFIX
201		-	+ "-windows-" + entry.getValue().toLowerCase()
202		-	+ ":" + imageVersion;
203		-	executions.add(new OsExecution(osMatcher, image, commands));
204		-	}
205		-
206		-	OsMatcher osMatcher = new OsMatcher("(?i).windows.", ".", ".");
207		-	String windowsImage = KubernetesHelper.IMAGE_REPO_PREFIX
208		-	+ "-windows-1809" + ":" + imageVersion;
209		-	executions.add(new OsExecution(osMatcher, windowsImage, commands));
210		-
211		-	return new CommandExecutable(executions, isUseTTY());
	76	+	public StepFacade getFacade(Build build, String jobToken, ParamCombination paramCombination) {
	77	+	return new BuildImageFacade(getBuildPath(), getDockerfile(), getTags(), isPublish());
212	78		}
213	79
214	80		}
		skipped 1 lines

■ ■ ■ ■ ■ ■

server-core/src/main/java/io/onedev/server/buildspec/step/CheckoutStep.java

		skipped 1 lines
2	2
3	3		import javax.validation.constraints.NotNull;
4	4
5		-	import io.onedev.k8shelper.CheckoutExecutable;
6		-	import io.onedev.k8shelper.Executable;
	5	+	import io.onedev.k8shelper.CheckoutFacade;
	6	+	import io.onedev.k8shelper.StepFacade;
7	7		import io.onedev.server.buildspec.job.gitcredential.DefaultCredential;
8	8		import io.onedev.server.buildspec.job.gitcredential.GitCredential;
9	9		import io.onedev.server.buildspec.param.ParamCombination;
		skipped 54 lines
64	64		}
65	65
66	66		@Override
67		-	public Executable getExecutable(Build build, String jobToken, ParamCombination paramCombination) {
68		-	return new CheckoutExecutable(cloneDepth!=null?cloneDepth:0, withLfs, withSubmodules,
	67	+	public StepFacade getFacade(Build build, String jobToken, ParamCombination paramCombination) {
	68	+	return new CheckoutFacade(cloneDepth!=null?cloneDepth:0, withLfs, withSubmodules,
69	69		cloneCredential.newCloneInfo(build, jobToken));
70	70		}
71	71
		skipped 2 lines

■ ■ ■ ■ ■ ■

server-core/src/main/java/io/onedev/server/buildspec/step/CloseMilestoneStep.java

		skipped 19 lines
20	20		import io.onedev.server.web.editable.annotation.Interpolative;
21	21
22	22		@Editable(name="Close Milestone", order=400)
23		-	public class CloseMilestoneStep extends ServerStep {
	23	+	public class CloseMilestoneStep extends ServerSideStep {
24	24
25	25		private static final long serialVersionUID = 1L;
26	26
		skipped 46 lines

■ ■ ■ ■ ■ ■

server-core/src/main/java/io/onedev/server/buildspec/step/CommandStep.java

		skipped 6 lines
7	7		import org.hibernate.validator.constraints.NotEmpty;
8	8
9	9		import io.onedev.commons.codeassist.InputSuggestion;
10		-	import io.onedev.k8shelper.Executable;
	10	+	import io.onedev.k8shelper.StepFacade;
11	11		import io.onedev.server.buildspec.BuildSpec;
12	12		import io.onedev.server.buildspec.param.ParamCombination;
13	13		import io.onedev.server.buildspec.step.commandinterpreter.DefaultInterpreter;
		skipped 73 lines
87	87		}
88	88
89	89		@Override
90		-	public Executable getExecutable(Build build, String jobToken, ParamCombination paramCombination) {
	90	+	public StepFacade getFacade(Build build, String jobToken, ParamCombination paramCombination) {
91	91		return getInterpreter().getExecutable(isRunInContainer()?getImage():null, isUseTTY());
92	92		}
93	93
		skipped 2 lines

■ ■ ■ ■ ■ ■

server-core/src/main/java/io/onedev/server/buildspec/step/CreateTagStep.java

		skipped 21 lines
22	22		import io.onedev.server.web.editable.annotation.Multiline;
23	23
24	24		@Editable(name="Create Tag", order=300)
25		-	public class CreateTagStep extends ServerStep {
	25	+	public class CreateTagStep extends ServerSideStep {
26	26
27	27		private static final long serialVersionUID = 1L;
28	28
		skipped 54 lines

■ ■ ■ ■ ■ ■

server-core/src/main/java/io/onedev/server/buildspec/step/PublishArtifactStep.java

		skipped 18 lines
19	19		import io.onedev.server.web.editable.annotation.Patterns;
20	20
21	21		@Editable(order=1050, name="Publish Artifacts")
22		-	public class PublishArtifactStep extends ServerStep {
	22	+	public class PublishArtifactStep extends ServerSideStep {
23	23
24	24		private static final long serialVersionUID = 1L;
25	25
		skipped 43 lines

■ ■ ■ ■ ■ ■

server-core/src/main/java/io/onedev/server/buildspec/step/PublishReportStep.java

		skipped 13 lines
14	14		import io.onedev.server.web.editable.annotation.Patterns;
15	15
16	16		@Editable
17		-	public abstract class PublishReportStep extends ServerStep {
	17	+	public abstract class PublishReportStep extends ServerSideStep {
18	18
19	19		private static final long serialVersionUID = 1L;
20	20
		skipped 51 lines

■ ■ ■ ■ ■ ■

server-core/src/main/java/io/onedev/server/buildspec/step/RunContainerStep.java

		skipped 9 lines
10	10		import org.hibernate.validator.constraints.NotEmpty;
11	11
12	12		import io.onedev.commons.codeassist.InputSuggestion;
13		-	import io.onedev.k8shelper.ContainerExecutable;
14		-	import io.onedev.k8shelper.Executable;
	13	+	import io.onedev.k8shelper.RunContainerFacade;
	14	+	import io.onedev.k8shelper.StepFacade;
15	15		import io.onedev.server.buildspec.BuildSpec;
16	16		import io.onedev.server.buildspec.job.EnvVar;
17	17		import io.onedev.server.buildspec.param.ParamCombination;
		skipped 17 lines
35	35		private boolean useTTY;
36	36
37	37		@Override
38		-	public Executable getExecutable(Build build, String jobToken, ParamCombination paramCombination) {
	38	+	public StepFacade getFacade(Build build, String jobToken, ParamCombination paramCombination) {
39	39		Map<String, String> envMap = new HashMap<>();
40	40		for (EnvVar var: getEnvVars())
41	41		envMap.put(var.getName(), var.getValue());
42		-	return new ContainerExecutable(getImage(), getArgs(), envMap, getWorkingDir(), isUseTTY());
	42	+	return new RunContainerFacade(getImage(), getArgs(), envMap, getWorkingDir(), isUseTTY());
43	43		}
44	44
45	45		@Editable(order=100, description="Specify container image to run. <b class='text-warning'>NOTE:</b> A shell must "
		skipped 64 lines

■ ■ ■ ■ ■ ■

server-core/src/main/java/io/onedev/server/buildspec/step/ServerStep.java server-core/src/main/java/io/onedev/server/buildspec/step/ServerSideStep.java

		skipped 8 lines
9	9		import javax.annotation.Nullable;
10	10
11	11		import io.onedev.commons.utils.TaskLogger;
12		-	import io.onedev.k8shelper.Executable;
	12	+	import io.onedev.k8shelper.StepFacade;
13	13		import io.onedev.k8shelper.KubernetesHelper;
14		-	import io.onedev.k8shelper.ServerExecutable;
	14	+	import io.onedev.k8shelper.ServerSideFacade;
15	15		import io.onedev.server.buildspec.param.ParamCombination;
16	16		import io.onedev.server.model.Build;
17	17		import io.onedev.server.util.patternset.PatternSet;
18	18		import io.onedev.server.web.editable.EditableStringVisitor;
19	19		import io.onedev.server.web.editable.annotation.Interpolative;
20	20
21		-	public abstract class ServerStep extends Step {
	21	+	public abstract class ServerSideStep extends Step {
22	22
23	23		private static final long serialVersionUID = 1L;
24	24
25	25		@Override
26		-	public Executable getExecutable(Build build, String jobToken, ParamCombination paramCombination) {
27		-	return new ServerExecutable(this, getFiles().getIncludes(), getFiles().getExcludes(), getPlaceholders());
	26	+	public StepFacade getFacade(Build build, String jobToken, ParamCombination paramCombination) {
	27	+	return new ServerSideFacade(this, getFiles().getIncludes(), getFiles().getExcludes(), getPlaceholders());
28	28		}
29	29
30	30		protected PatternSet getFiles() {
		skipped 22 lines

■ ■ ■ ■ ■ ■

server-core/src/main/java/io/onedev/server/buildspec/step/SetBuildVersionStep.java

		skipped 22 lines
23	23		import io.onedev.server.web.editable.annotation.Interpolative;
24	24
25	25		@Editable(order=260, name="Set Build Version")
26		-	public class SetBuildVersionStep extends ServerStep {
	26	+	public class SetBuildVersionStep extends ServerSideStep {
27	27
28	28		private static final long serialVersionUID = 1L;
29	29
		skipped 37 lines

■ ■ ■ ■ ■ ■

server-core/src/main/java/io/onedev/server/buildspec/step/Step.java

		skipped 6 lines
7	7		import org.hibernate.validator.constraints.NotEmpty;
8	8
9	9		import io.onedev.k8shelper.Action;
10		-	import io.onedev.k8shelper.Executable;
	10	+	import io.onedev.k8shelper.StepFacade;
11	11		import io.onedev.k8shelper.ExecuteCondition;
12	12		import io.onedev.server.buildspec.param.ParamCombination;
13	13		import io.onedev.server.model.Build;
		skipped 6 lines
20	20
21	21		private ExecuteCondition condition = ExecuteCondition.ALL_PREVIOUS_STEPS_WERE_SUCCESSFUL;
22	22
23		-	public abstract Executable getExecutable(Build build, String jobToken, ParamCombination paramCombination);
	23	+	public abstract StepFacade getFacade(Build build, String jobToken, ParamCombination paramCombination);
24	24
25	25		private String name;
26	26
		skipped 18 lines
45	45		}
46	46
47	47		public Action getAction(String name, Build build, String jobToken, ParamCombination paramCombination) {
48		-	return new Action(name, getExecutable(build, jobToken, paramCombination), condition);
	48	+	return new Action(name, getFacade(build, jobToken, paramCombination), condition);
49	49		}
50	50
51	51		public Action getAction(Build build, String jobToken, ParamCombination paramCombination) {
		skipped 5 lines

■ ■ ■ ■ ■ ■

server-core/src/main/java/io/onedev/server/buildspec/step/UseTemplateStep.java

		skipped 11 lines
12	12
13	13		import io.onedev.commons.utils.ExplicitException;
14	14		import io.onedev.k8shelper.Action;
15		-	import io.onedev.k8shelper.CompositeExecutable;
16		-	import io.onedev.k8shelper.Executable;
	15	+	import io.onedev.k8shelper.CompositeFacade;
	16	+	import io.onedev.k8shelper.StepFacade;
17	17		import io.onedev.server.buildspec.BuildSpec;
18	18		import io.onedev.server.buildspec.param.ParamCombination;
19	19		import io.onedev.server.buildspec.param.ParamUtils;
		skipped 69 lines
89	89		}
90	90
91	91		@Override
92		-	public Executable getExecutable(Build build, String jobToken, ParamCombination paramCombination) {
	92	+	public StepFacade getFacade(Build build, String jobToken, ParamCombination paramCombination) {
93	93		StepTemplate template = build.getSpec().getStepTemplateMap().get(templateName);
94	94		if (template == null)
95	95		throw new ExplicitException("Step template not found: " + templateName);
		skipped 20 lines
116	116
117	117		}.run();
118	118
119		-	return new CompositeExecutable(actions);
	119	+	return new CompositeFacade(actions);
120	120		}
121	121
122	122		}
		skipped 1 lines

■ ■ ■ ■ ■ ■

server-core/src/main/java/io/onedev/server/buildspec/step/commandinterpreter/BashInterpreter.java

		skipped 3 lines
4	4
5	5		import javax.validation.constraints.Size;
6	6
7		-	import io.onedev.k8shelper.BashExecutable;
8		-	import io.onedev.k8shelper.CommandExecutable;
	7	+	import io.onedev.k8shelper.BashFacade;
	8	+	import io.onedev.k8shelper.CommandFacade;
9	9		import io.onedev.server.util.validation.annotation.Code;
10	10		import io.onedev.server.web.editable.annotation.Editable;
11	11		import io.onedev.server.web.editable.annotation.Interpolative;
		skipped 17 lines
29	29		}
30	30
31	31		@Override
32		-	public CommandExecutable getExecutable(String image, boolean useTTY) {
33		-	return new BashExecutable(image, getCommands(), useTTY);
	32	+	public CommandFacade getExecutable(String image, boolean useTTY) {
	33	+	return new BashFacade(image, getCommands(), useTTY);
34	34		}
35	35
36	36		}
		skipped 1 lines

■ ■ ■ ■ ■ ■

server-core/src/main/java/io/onedev/server/buildspec/step/commandinterpreter/DefaultInterpreter.java

		skipped 3 lines
4	4
5	5		import javax.validation.constraints.Size;
6	6
7		-	import io.onedev.k8shelper.CommandExecutable;
	7	+	import io.onedev.k8shelper.CommandFacade;
8	8		import io.onedev.server.util.validation.annotation.Code;
9	9		import io.onedev.server.web.editable.annotation.Editable;
10	10		import io.onedev.server.web.editable.annotation.Interpolative;
		skipped 17 lines
28	28		}
29	29
30	30		@Override
31		-	public CommandExecutable getExecutable(String image, boolean useTTY) {
32		-	return new CommandExecutable(image, getCommands(), useTTY);
	31	+	public CommandFacade getExecutable(String image, boolean useTTY) {
	32	+	return new CommandFacade(image, getCommands(), useTTY);
33	33		}
34	34
35	35		}
		skipped 1 lines

■ ■ ■ ■ ■ ■

server-core/src/main/java/io/onedev/server/buildspec/step/commandinterpreter/Interpreter.java

		skipped 6 lines
7	7		import javax.annotation.Nullable;
8	8
9	9		import io.onedev.commons.codeassist.InputSuggestion;
10		-	import io.onedev.k8shelper.CommandExecutable;
	10	+	import io.onedev.k8shelper.CommandFacade;
11	11		import io.onedev.server.buildspec.BuildSpec;
12	12		import io.onedev.server.web.editable.annotation.Editable;
13	13
		skipped 12 lines
26	26		this.commands = commands;
27	27		}
28	28
29		-	public abstract CommandExecutable getExecutable(@Nullable String image, boolean useTTY);
	29	+	public abstract CommandFacade getExecutable(@Nullable String image, boolean useTTY);
30	30
31	31		static List<InputSuggestion> suggestVariables(String matchWith) {
32	32		return BuildSpec.suggestVariables(matchWith, false, false);
		skipped 4 lines

■ ■ ■ ■ ■ ■

server-core/src/main/java/io/onedev/server/buildspec/step/commandinterpreter/PowerShellInterpreter.java

		skipped 3 lines
4	4
5	5		import javax.validation.constraints.Size;
6	6
7		-	import io.onedev.k8shelper.CommandExecutable;
8		-	import io.onedev.k8shelper.PowerShellExecutable;
	7	+	import io.onedev.k8shelper.CommandFacade;
	8	+	import io.onedev.k8shelper.PowerShellFacade;
9	9		import io.onedev.server.util.validation.annotation.Code;
10	10		import io.onedev.server.web.editable.annotation.Editable;
11	11		import io.onedev.server.web.editable.annotation.Interpolative;
		skipped 21 lines
33	33		}
34	34
35	35		@Override
36		-	public CommandExecutable getExecutable(String image, boolean useTTY) {
37		-	return new PowerShellExecutable(image, getCommands(), useTTY);
	36	+	public CommandFacade getExecutable(String image, boolean useTTY) {
	37	+	return new PowerShellFacade(image, getCommands(), useTTY);
38	38		}
39	39
40	40		}
		skipped 1 lines

■ ■ ■ ■ ■ ■

server-plugin/server-plugin-executor-kubernetes/src/main/java/io/onedev/server/plugin/executor/kubernetes/KubernetesExecutor.java

		skipped 56 lines
57	57		import io.onedev.commons.utils.command.ExecutionResult;
58	58		import io.onedev.commons.utils.command.LineConsumer;
59	59		import io.onedev.k8shelper.Action;
60		-	import io.onedev.k8shelper.CommandExecutable;
61		-	import io.onedev.k8shelper.CompositeExecutable;
62		-	import io.onedev.k8shelper.ContainerExecutable;
	60	+	import io.onedev.k8shelper.BuildImageFacade;
	61	+	import io.onedev.k8shelper.CommandFacade;
	62	+	import io.onedev.k8shelper.CompositeFacade;
63	63		import io.onedev.k8shelper.ExecuteCondition;
64	64		import io.onedev.k8shelper.KubernetesHelper;
65		-	import io.onedev.k8shelper.LeafExecutable;
	65	+	import io.onedev.k8shelper.LeafFacade;
66	66		import io.onedev.k8shelper.LeafVisitor;
67	67		import io.onedev.k8shelper.OsContainer;
68	68		import io.onedev.k8shelper.OsExecution;
69	69		import io.onedev.k8shelper.OsInfo;
	70	+	import io.onedev.k8shelper.RegistryLoginFacade;
	71	+	import io.onedev.k8shelper.RunContainerFacade;
70	72		import io.onedev.server.OneDev;
71	73		import io.onedev.server.buildspec.Service;
72	74		import io.onedev.server.buildspec.job.EnvVar;
		skipped 692 lines
765	767		commonVolumeMounts.add(dockerSockMount);
766	768		commonVolumeMounts.add(containerdSockMount);
767	769
768		-	CompositeExecutable entryExecutable;
	770	+	CompositeFacade entryFacade;
769	771		if (jobContext != null) {
770		-	entryExecutable = new CompositeExecutable(jobContext.getActions());
	772	+	entryFacade = new CompositeFacade(jobContext.getActions());
771	773		} else {
772	774		List<Action> actions = new ArrayList<>();
773		-	CommandExecutable executable = new CommandExecutable((String) executionContext,
	775	+	CommandFacade facade = new CommandFacade((String) executionContext,
774	776		Lists.newArrayList("this does not matter"), false);
775		-	actions.add(new Action("test", executable, ExecuteCondition.ALWAYS));
776		-	entryExecutable = new CompositeExecutable(actions);
	777	+	actions.add(new Action("test", facade, ExecuteCondition.ALWAYS));
	778	+	entryFacade = new CompositeFacade(actions);
777	779		}
778	780
779	781		List<String> containerNames = Lists.newArrayList("init");
		skipped 23 lines
803	805		"value", Hex.encodeHexString(SerializationUtils.serialize(osInfo))
804	806		));
805	807
806		-	entryExecutable.traverse(new LeafVisitor<Void>() {
	808	+	entryFacade.traverse(new LeafVisitor<Void>() {
807	809
808	810		@Override
809		-	public Void visit(LeafExecutable executable, List<Integer> position) {
	811	+	public Void visit(LeafFacade facade, List<Integer> position) {
810	812		String containerName = getContainerName(position);
811	813		containerNames.add(containerName);
812	814		Map<Object, Object> stepContainerSpec;
813		-	if (executable instanceof CommandExecutable) {
814		-	CommandExecutable commandExecutable = (CommandExecutable) executable;
815		-	OsExecution execution = commandExecutable.getExecution(osInfo);
	815	+	if (facade instanceof CommandFacade) {
	816	+	CommandFacade commandFacade = (CommandFacade) facade;
	817	+	OsExecution execution = commandFacade.getExecution(osInfo);
816	818		if (execution.getImage() == null) {
817	819		throw new ExplicitException("This step can only be executed by server shell "
818	820		+ "executor or remote shell executor");
		skipped 2 lines
821	823		stepContainerSpec = CollectionUtils.newHashMap(
822	824		"name", containerName,
823	825		"image", execution.getImage());
824		-	if (commandExecutable.isUseTTY())
	826	+	if (commandFacade.isUseTTY())
825	827		stepContainerSpec.put("tty", true);
826	828		stepContainerSpec.put("volumeMounts", commonVolumeMounts);
827	829		stepContainerSpec.put("env", commonEnvs);
828		-	} else if (executable instanceof ContainerExecutable) {
829		-	ContainerExecutable containerExecutable = (ContainerExecutable) executable;
830		-	OsContainer container = containerExecutable.getContainer(osInfo);
	830	+	} else if (facade instanceof BuildImageFacade) {
	831	+	stepContainerSpec = CollectionUtils.newHashMap(
	832	+	"name", containerName,
	833	+	"image", helperImage);
	834	+	stepContainerSpec.put("volumeMounts", commonVolumeMounts);
	835	+	stepContainerSpec.put("env", commonEnvs);
	836	+	} else if (facade instanceof RunContainerFacade) {
	837	+	RunContainerFacade runContainerFacade = (RunContainerFacade) facade;
	838	+	OsContainer container = runContainerFacade.getContainer(osInfo);
831	839		stepContainerSpec = CollectionUtils.newHashMap(
832	840		"name", containerName,
833	841		"image", container.getImage());
834		-	if (containerExecutable.isUseTTY())
	842	+	if (runContainerFacade.isUseTTY())
835	843		stepContainerSpec.put("tty", true);
836	844		List<Object> volumeMounts = new ArrayList<>(commonVolumeMounts);
837	845		if (container.getWorkingDir() != null) {
		skipped 52 lines
890	898		initArgs.add("test");
891	899		}
892	900
	901	+	List<Map<Object, Object>> initEnvs = new ArrayList<>(commonEnvs);
	902	+	List<RegistryLoginFacade> registryLogins = new ArrayList<>();
	903	+	for (RegistryLogin login: getRegistryLogins())
	904	+	registryLogins.add(new RegistryLoginFacade(login.getRegistryUrl(), login.getUserName(), login.getPassword()));
	905	+	initEnvs.add(CollectionUtils.newLinkedHashMap(
	906	+	"name", KubernetesHelper.ENV_REGISTRY_LOGINS,
	907	+	"value", Hex.encodeHexString(SerializationUtils.serialize((Serializable) registryLogins))
	908	+	));
893	909		Map<Object, Object> initContainerSpec = CollectionUtils.newHashMap(
894	910		"name", "init",
895	911		"image", helperImage,
896	912		"command", Lists.newArrayList("java"),
897	913		"args", initArgs,
898		-	"env", commonEnvs,
	914	+	"env", initEnvs,
899	915		"volumeMounts", commonVolumeMounts);
900	916
901	917		Map<Object, Object> sidecarContainerSpec = CollectionUtils.newHashMap(
		skipped 109 lines
1011	1027		String errorMessage;
1012	1028		if (containerName.startsWith("step-")) {
1013	1029		List<Integer> position = KubernetesHelper.parsePosition(containerName.substring("step-".length()));
1014		-	errorMessage = "Step \"" + entryExecutable.getNamesAsString(position)
	1030	+	errorMessage = "Step \"" + entryFacade.getNamesAsString(position)
1015	1031		+ ": " + error.getMessage();
1016	1032		} else {
1017	1033		errorMessage = containerName + ": " + error.getMessage();
		skipped 28 lines
1046	1062		String errorMessage;
1047	1063		if (containerName.startsWith("step-")) {
1048	1064		List<Integer> position = KubernetesHelper.parsePosition(containerName.substring("step-".length()));
1049		-	errorMessage = "Step \"" + entryExecutable.getNamesAsString(position)
	1065	+	errorMessage = "Step \"" + entryFacade.getNamesAsString(position)
1050	1066		+ " is failed: " + error.getMessage();
1051	1067		} else {
1052	1068		errorMessage = containerName + ": " + error.getMessage();
		skipped 350 lines

■ ■ ■ ■ ■ ■

server-plugin/server-plugin-executor-serverdocker/src/main/java/io/onedev/server/plugin/executor/serverdocker/ServerDockerExecutor.java

		skipped 54 lines
55	55		import io.onedev.commons.utils.command.Commandline;
56	56		import io.onedev.commons.utils.command.ExecutionResult;
57	57		import io.onedev.commons.utils.command.LineConsumer;
	58	+	import io.onedev.k8shelper.BuildImageFacade;
58	59		import io.onedev.k8shelper.CacheInstance;
59		-	import io.onedev.k8shelper.CheckoutExecutable;
	60	+	import io.onedev.k8shelper.CheckoutFacade;
60	61		import io.onedev.k8shelper.CloneInfo;
61		-	import io.onedev.k8shelper.CommandExecutable;
62		-	import io.onedev.k8shelper.CompositeExecutable;
63		-	import io.onedev.k8shelper.ContainerExecutable;
	62	+	import io.onedev.k8shelper.CommandFacade;
	63	+	import io.onedev.k8shelper.CompositeFacade;
	64	+	import io.onedev.k8shelper.RunContainerFacade;
64	65		import io.onedev.k8shelper.KubernetesHelper;
65		-	import io.onedev.k8shelper.LeafExecutable;
	66	+	import io.onedev.k8shelper.LeafFacade;
66	67		import io.onedev.k8shelper.LeafHandler;
67	68		import io.onedev.k8shelper.OsContainer;
68	69		import io.onedev.k8shelper.OsExecution;
69	70		import io.onedev.k8shelper.OsInfo;
70		-	import io.onedev.k8shelper.ServerExecutable;
	71	+	import io.onedev.k8shelper.ServerSideFacade;
71	72		import io.onedev.server.OneDev;
72	73		import io.onedev.server.buildspec.Service;
73	74		import io.onedev.server.buildspec.job.JobContext;
		skipped 140 lines
214	215		}
215	216
216	217		jobContext.reportJobWorkspace(containerWorkspace);
217		-	CompositeExecutable entryExecutable = new CompositeExecutable(jobContext.getActions());
218		-	boolean successful = entryExecutable.execute(new LeafHandler() {
	218	+	CompositeFacade entryFacade = new CompositeFacade(jobContext.getActions());
	219	+	boolean successful = entryFacade.execute(new LeafHandler() {
219	220
220	221		private int runStepContainer(String image, @Nullable String entrypoint,
221	222		List<String> arguments, Map<String, String> environments,
		skipped 52 lines
274	275		docker.addArgs(arguments.toArray(new String[arguments.size()]));
275	276
276	277		ExecutionResult result = docker.execute(ExecutorUtils.newInfoLogger(jobLogger),
277		-	ExecutorUtils.newErrorLogger(jobLogger), null, newDockerKiller(newDocker(),
	278	+	ExecutorUtils.newWarningLogger(jobLogger), null, newDockerKiller(newDocker(),
278	279		containerName, jobLogger));
279	280		return result.getReturnCode();
280	281		}
281	282
282	283		@Override
283		-	public boolean execute(LeafExecutable executable, List<Integer> position) {
284		-	String stepNames = entryExecutable.getNamesAsString(position);
	284	+	public boolean execute(LeafFacade facade, List<Integer> position) {
	285	+	String stepNames = entryFacade.getNamesAsString(position);
285	286		jobLogger.notice("Running step \"" + stepNames + "\"...");
286	287
287		-	if (executable instanceof CommandExecutable) {
288		-	CommandExecutable commandExecutable = (CommandExecutable) executable;
	288	+	if (facade instanceof CommandFacade) {
	289	+	CommandFacade commandFacade = (CommandFacade) facade;
289	290
290		-	OsExecution execution = commandExecutable.getExecution(osInfo);
	291	+	OsExecution execution = commandFacade.getExecution(osInfo);
291	292		if (execution.getImage() == null) {
292	293		throw new ExplicitException("This step can only be executed by server shell "
293	294		+ "executor or remote shell executor");
294	295		}
295	296
296	297		Commandline entrypoint = DockerExecutorUtils.getEntrypoint(
297		-	hostBuildHome, commandExecutable, osInfo, hostAuthInfoHome.get() != null);
	298	+	hostBuildHome, commandFacade, osInfo, hostAuthInfoHome.get() != null);
298	299
299	300		int exitCode = runStepContainer(execution.getImage(), entrypoint.executable(),
300		-	entrypoint.arguments(), new HashMap<>(), null, position, commandExecutable.isUseTTY());
	301	+	entrypoint.arguments(), new HashMap<>(), null, position, commandFacade.isUseTTY());
301	302
302	303		if (exitCode != 0) {
303	304		jobLogger.error("Step \"" + stepNames + "\" is failed: Command exited with code " + exitCode);
304	305		return false;
305	306		}
306		-	} else if (executable instanceof ContainerExecutable) {
307		-	ContainerExecutable containerExecutable = (ContainerExecutable) executable;
308		-	OsContainer container = containerExecutable.getContainer(osInfo);
	307	+	} else if (facade instanceof BuildImageFacade \|\| facade instanceof BuildImageFacade) {
	308	+	DockerExecutorUtils.buildImage(newDocker(), (BuildImageFacade) facade,
	309	+	hostWorkspace, jobLogger);
	310	+	} else if (facade instanceof RunContainerFacade) {
	311	+	RunContainerFacade rubContainerFacade = (RunContainerFacade) facade;
	312	+	OsContainer container = rubContainerFacade.getContainer(osInfo);
309	313		List<String> arguments = new ArrayList<>();
310	314		if (container.getArgs() != null)
311	315		arguments.addAll(Arrays.asList(StringUtils.parseQuoteTokens(container.getArgs())));
312	316		int exitCode = runStepContainer(container.getImage(), null, arguments, container.getEnvMap(),
313		-	container.getWorkingDir(), position, containerExecutable.isUseTTY());
	317	+	container.getWorkingDir(), position, rubContainerFacade.isUseTTY());
314	318		if (exitCode != 0) {
315	319		jobLogger.error("Step \"" + stepNames + "\" is failed: Container exited with code " + exitCode);
316	320		return false;
317	321		}
318		-	} else if (executable instanceof CheckoutExecutable) {
	322	+	} else if (facade instanceof CheckoutFacade) {
319	323		try {
320		-	CheckoutExecutable checkoutExecutable = (CheckoutExecutable) executable;
	324	+	CheckoutFacade checkoutFacade = (CheckoutFacade) facade;
321	325		jobLogger.log("Checking out code...");
322	326		if (hostAuthInfoHome.get() == null)
323	327		hostAuthInfoHome.set(FileUtils.createTempDir());
324	328		Commandline git = new Commandline(AppLoader.getInstance(GitConfig.class).getExecutable());
325	329		git.workingDir(hostWorkspace).environments().put("HOME", hostAuthInfoHome.get().getAbsolutePath());
326	330
327		-	CloneInfo cloneInfo = checkoutExecutable.getCloneInfo();
	331	+	CloneInfo cloneInfo = checkoutFacade.getCloneInfo();
328	332
329		-	cloneInfo.writeAuthData(hostAuthInfoHome.get(), git, ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newErrorLogger(jobLogger));
	333	+	cloneInfo.writeAuthData(hostAuthInfoHome.get(), git, ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newWarningLogger(jobLogger));
330	334		try {
331	335		List<String> trustCertContent = getTrustCertContent();
332	336		if (!trustCertContent.isEmpty()) {
333	337		installGitCert(new File(hostAuthInfoHome.get(), "trust-cert.pem"), trustCertContent,
334		-	git, ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newErrorLogger(jobLogger));
	338	+	git, ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newWarningLogger(jobLogger));
335	339		}
336	340
337		-	int cloneDepth = checkoutExecutable.getCloneDepth();
	341	+	int cloneDepth = checkoutFacade.getCloneDepth();
338	342
339	343		cloneRepository(git, jobContext.getProjectGitDir().getAbsolutePath(),
340	344		cloneInfo.getCloneUrl(), jobContext.getCommitId().name(),
341		-	checkoutExecutable.isWithLfs(), checkoutExecutable.isWithSubmodules(),
342		-	cloneDepth, ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newErrorLogger(jobLogger));
	345	+	checkoutFacade.isWithLfs(), checkoutFacade.isWithSubmodules(),
	346	+	cloneDepth, ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newWarningLogger(jobLogger));
343	347		} finally {
344	348		git.clearArgs();
345	349		git.addArgs("config", "--global", "--unset", "core.sshCommand");
346		-	ExecutionResult result = git.execute(ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newErrorLogger(jobLogger));
	350	+	ExecutionResult result = git.execute(ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newWarningLogger(jobLogger));
347	351		if (result.getReturnCode() != 5 && result.getReturnCode() != 0)
348	352		result.checkReturnCode();
349	353		}
		skipped 2 lines
352	356		return false;
353	357		}
354	358		} else {
355		-	ServerExecutable serverExecutable = (ServerExecutable) executable;
	359	+	ServerSideFacade serverSideFacade = (ServerSideFacade) facade;
356	360
357	361		File filesDir = FileUtils.createTempDir();
358	362		try {
359		-	Collection<String> placeholders = serverExecutable.getPlaceholders();
	363	+	Collection<String> placeholders = serverSideFacade.getPlaceholders();
360	364		Map<String, String> placeholderValues = readPlaceholderValues(hostBuildHome, placeholders);
361	365		PatternSet filePatterns = new PatternSet(
362		-	new HashSet<>(replacePlaceholders(serverExecutable.getIncludeFiles(), placeholderValues)),
363		-	new HashSet<>(replacePlaceholders(serverExecutable.getExcludeFiles(), placeholderValues)));
	366	+	new HashSet<>(replacePlaceholders(serverSideFacade.getIncludeFiles(), placeholderValues)),
	367	+	new HashSet<>(replacePlaceholders(serverSideFacade.getExcludeFiles(), placeholderValues)));
364	368
365	369		int baseLen = hostWorkspace.getAbsolutePath().length()+1;
366	370		for (File file: filePatterns.listFiles(hostWorkspace)) {
		skipped 25 lines
392	396		}
393	397
394	398		@Override
395		-	public void skip(LeafExecutable executable, List<Integer> position) {
396		-	jobLogger.notice("Step \"" + entryExecutable.getNamesAsString(position) + "\" is skipped");
	399	+	public void skip(LeafFacade facade, List<Integer> position) {
	400	+	jobLogger.notice("Step \"" + entryFacade.getNamesAsString(position) + "\" is skipped");
397	401		}
398	402
399	403		}, new ArrayList<>());
		skipped 243 lines

■ ■ ■ ■ ■ ■

server-plugin/server-plugin-executor-servershell/src/main/java/io/onedev/server/plugin/executor/servershell/ServerShellExecutor.java

		skipped 34 lines
35	35		import io.onedev.commons.utils.command.Commandline;
36	36		import io.onedev.commons.utils.command.ExecutionResult;
37	37		import io.onedev.k8shelper.CacheInstance;
38		-	import io.onedev.k8shelper.CheckoutExecutable;
	38	+	import io.onedev.k8shelper.CheckoutFacade;
39	39		import io.onedev.k8shelper.CloneInfo;
40		-	import io.onedev.k8shelper.CommandExecutable;
41		-	import io.onedev.k8shelper.CompositeExecutable;
42		-	import io.onedev.k8shelper.ContainerExecutable;
43		-	import io.onedev.k8shelper.LeafExecutable;
	40	+	import io.onedev.k8shelper.CommandFacade;
	41	+	import io.onedev.k8shelper.CompositeFacade;
	42	+	import io.onedev.k8shelper.RunContainerFacade;
	43	+	import io.onedev.k8shelper.LeafFacade;
44	44		import io.onedev.k8shelper.LeafHandler;
45	45		import io.onedev.k8shelper.OsExecution;
46	46		import io.onedev.k8shelper.OsInfo;
47		-	import io.onedev.k8shelper.ServerExecutable;
	47	+	import io.onedev.k8shelper.ServerSideFacade;
48	48		import io.onedev.server.OneDev;
49	49		import io.onedev.server.buildspec.job.CacheSpec;
50	50		import io.onedev.server.buildspec.job.JobContext;
		skipped 76 lines
127	127
128	128		jobContext.reportJobWorkspace(workspaceDir.getAbsolutePath());
129	129
130		-	CompositeExecutable entryExecutable = new CompositeExecutable(jobContext.getActions());
	130	+	CompositeFacade entryFacade = new CompositeFacade(jobContext.getActions());
131	131
132	132		OsInfo osInfo = OneDev.getInstance(OsInfo.class);
133		-	boolean successful = entryExecutable.execute(new LeafHandler() {
	133	+	boolean successful = entryFacade.execute(new LeafHandler() {
134	134
135	135		@Override
136		-	public boolean execute(LeafExecutable executable, List<Integer> position) {
137		-	String stepNames = entryExecutable.getNamesAsString(position);
	136	+	public boolean execute(LeafFacade facade, List<Integer> position) {
	137	+	String stepNames = entryFacade.getNamesAsString(position);
138	138		jobLogger.notice("Running step \"" + stepNames + "\"...");
139	139
140		-	if (executable instanceof CommandExecutable) {
141		-	CommandExecutable commandExecutable = (CommandExecutable) executable;
142		-	OsExecution execution = commandExecutable.getExecution(osInfo);
	140	+	if (facade instanceof CommandFacade) {
	141	+	CommandFacade commandFacade = (CommandFacade) facade;
	142	+	OsExecution execution = commandFacade.getExecution(osInfo);
143	143		if (execution.getImage() != null) {
144	144		throw new ExplicitException("This step can only be executed by server docker executor, "
145	145		+ "remote docker executor, or kubernetes executor");
146	146		}
147	147
148		-	File jobScriptFile = new File(buildDir, "job-commands" + commandExecutable.getScriptExtension());
	148	+	File jobScriptFile = new File(buildDir, "job-commands" + commandFacade.getScriptExtension());
149	149		try {
150	150		FileUtils.writeLines(
151	151		jobScriptFile,
152	152		new ArrayList<>(replacePlaceholders(execution.getCommands(), buildDir)),
153		-	commandExecutable.getEndOfLine());
	153	+	commandFacade.getEndOfLine());
154	154		} catch (IOException e) {
155	155		throw new RuntimeException(e);
156	156		}
		skipped 16 lines
173	173		}
174	174		}
175	175
176		-	Commandline interpreter = commandExecutable.getInterpreter();
	176	+	Commandline interpreter = commandFacade.getInterpreter();
177	177		Map<String, String> environments = new HashMap<>();
178	178		environments.put("GIT_HOME", userDir.getAbsolutePath());
179	179		interpreter.workingDir(workspaceDir).environments(environments);
180	180		interpreter.addArgs(jobScriptFile.getAbsolutePath());
181	181
182		-	ExecutionResult result = interpreter.execute(ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newErrorLogger(jobLogger));
	182	+	ExecutionResult result = interpreter.execute(ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newWarningLogger(jobLogger));
183	183		if (result.getReturnCode() != 0) {
184	184		jobLogger.error("Step \"" + stepNames + "\" is failed: Command exited with code " + result.getReturnCode());
185	185		return false;
186	186		}
187		-	} else if (executable instanceof ContainerExecutable) {
	187	+	} else if (facade instanceof RunContainerFacade) {
188	188		throw new ExplicitException("This step can only be executed by server docker executor, "
189	189		+ "remote docker executor, or kubernetes executor");
190		-	} else if (executable instanceof CheckoutExecutable) {
	190	+	} else if (facade instanceof CheckoutFacade) {
191	191		try {
192		-	CheckoutExecutable checkoutExecutable = (CheckoutExecutable) executable;
	192	+	CheckoutFacade checkoutFacade = (CheckoutFacade) facade;
193	193		jobLogger.log("Checking out code...");
194	194		Commandline git = new Commandline(AppLoader.getInstance(GitConfig.class).getExecutable());
195	195		git.workingDir(workspaceDir);
		skipped 1 lines
197	197		environments.put("HOME", userDir.getAbsolutePath());
198	198		git.environments(environments);
199	199
200		-	CloneInfo cloneInfo = checkoutExecutable.getCloneInfo();
	200	+	CloneInfo cloneInfo = checkoutFacade.getCloneInfo();
201	201
202		-	cloneInfo.writeAuthData(userDir, git, ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newErrorLogger(jobLogger));
	202	+	cloneInfo.writeAuthData(userDir, git, ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newWarningLogger(jobLogger));
203	203
204	204		List<String> trustCertContent = getTrustCertContent();
205	205		if (!trustCertContent.isEmpty()) {
206	206		installGitCert(new File(userDir, "trust-cert.pem"), trustCertContent,
207		-	git, ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newErrorLogger(jobLogger));
	207	+	git, ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newWarningLogger(jobLogger));
208	208		}
209	209
210		-	int cloneDepth = checkoutExecutable.getCloneDepth();
	210	+	int cloneDepth = checkoutFacade.getCloneDepth();
211	211
212	212		cloneRepository(git, jobContext.getProjectGitDir().getAbsolutePath(),
213	213		cloneInfo.getCloneUrl(), jobContext.getCommitId().name(),
214		-	checkoutExecutable.isWithLfs(), checkoutExecutable.isWithSubmodules(),
215		-	cloneDepth, ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newErrorLogger(jobLogger));
	214	+	checkoutFacade.isWithLfs(), checkoutFacade.isWithSubmodules(),
	215	+	cloneDepth, ExecutorUtils.newInfoLogger(jobLogger), ExecutorUtils.newWarningLogger(jobLogger));
216	216		} catch (Exception e) {
217	217		jobLogger.error("Step \"" + stepNames + "\" is failed: " + getErrorMessage(e));
218	218		return false;
219	219		}
220	220		} else {
221		-	ServerExecutable serverExecutable = (ServerExecutable) executable;
	221	+	ServerSideFacade serverSideFacade = (ServerSideFacade) facade;
222	222
223	223		File filesDir = FileUtils.createTempDir();
224	224		try {
225		-	Collection<String> placeholders = serverExecutable.getPlaceholders();
	225	+	Collection<String> placeholders = serverSideFacade.getPlaceholders();
226	226		Map<String, String> placeholderValues = readPlaceholderValues(buildDir, placeholders);
227	227		PatternSet filePatterns = new PatternSet(
228		-	new HashSet<>(replacePlaceholders(serverExecutable.getIncludeFiles(), placeholderValues)),
229		-	new HashSet<>(replacePlaceholders(serverExecutable.getExcludeFiles(), placeholderValues)));
	228	+	new HashSet<>(replacePlaceholders(serverSideFacade.getIncludeFiles(), placeholderValues)),
	229	+	new HashSet<>(replacePlaceholders(serverSideFacade.getExcludeFiles(), placeholderValues)));
230	230
231	231		int baseLen = workspaceDir.getAbsolutePath().length()+1;
232	232		for (File file: filePatterns.listFiles(workspaceDir)) {
		skipped 25 lines
258	258		}
259	259
260	260		@Override
261		-	public void skip(LeafExecutable executable, List<Integer> position) {
262		-	jobLogger.notice("Step \"" + entryExecutable.getNamesAsString(position) + "\" is skipped");
	261	+	public void skip(LeafFacade facade, List<Integer> position) {
	262	+	jobLogger.notice("Step \"" + entryFacade.getNamesAsString(position) + "\" is skipped");
263	263		}
264	264
265	265		}, new ArrayList<>());
		skipped 47 lines

■ ■ ■ ■ ■ ■

server-product/system/incompatibilities/incompatibilities.md

	1	+	# 6.2.1
	2	+
	3	+	1. [build spec] Registry login setting is removed from build image step (introduced in 6.2.0). Specify registry logins
	4	+	in job executor if necessary
	5	+
1	6		# 6.2.0
2	7
3	8		1. A new property `Run In Container` is added and enabled for all command steps in build spec. If you have steps intended to
		skipped 54 lines

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