The Unified and Autonomous Development Platform
Migration from existing xml based build spec
Robin Shen80ca2015f5a6
diff --git a/server-core/src/main/java/io/onedev/server/buildspec/BuildSpec.java b/server-core/src/main/java/io/onedev/server/buildspec/BuildSpec.javaindex fd4ffca3b3..e08f7f332d 100644--- a/server-core/src/main/java/io/onedev/server/buildspec/BuildSpec.java+++ b/server-core/src/main/java/io/onedev/server/buildspec/BuildSpec.java@@ -24,6 +24,7 @@ import io.onedev.server.buildspec.job.paramsupply.ParamSupply;import io.onedev.server.buildspec.job.retrycondition.RetryCondition;import io.onedev.server.buildspec.job.trigger.JobTrigger;import io.onedev.server.migration.VersionedYamlDoc;+import io.onedev.server.migration.XmlBuildSpecMigrator;import io.onedev.server.util.validation.Validatable;import io.onedev.server.util.validation.annotation.ClassValidating;import io.onedev.server.web.editable.annotation.Editable;@@ -206,6 +207,8 @@ public class BuildSpec implements Serializable, Validatable {public static BuildSpec parse(byte[] bytes) {String buildSpecString = new String(bytes, StandardCharsets.UTF_8);if (StringUtils.isNotBlank(buildSpecString)) {+ if (buildSpecString.trim().startsWith("<?xml"))+ buildSpecString = XmlBuildSpecMigrator.migrate(buildSpecString);try {return VersionedYamlDoc.fromYaml(buildSpecString).toBean(BuildSpec.class);} catch (Exception e) {diff --git a/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/Ignore.java b/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/Ignore.javaindex fb176975b7..dbff87e7d9 100644--- a/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/Ignore.java+++ b/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/Ignore.java@@ -7,7 +7,7 @@ import org.apache.commons.lang3.builder.HashCodeBuilder;import io.onedev.server.web.editable.annotation.Editable;-@Editable+@Editable(name="Ignore")public class Ignore implements ValuesProvider {private static final long serialVersionUID = 1L;diff --git a/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/ParamSupply.java b/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/ParamSupply.javaindex 61a225a5b6..97ea0c792b 100644--- a/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/ParamSupply.java+++ b/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/ParamSupply.java@@ -49,6 +49,7 @@ public class ParamSupply implements Serializable {private ValuesProvider valuesProvider = new SpecifiedValues();+ @Editable@NotEmptypublic String getName() {return name;@@ -58,6 +59,7 @@ public class ParamSupply implements Serializable {this.name = name;}+ @Editable@NotNull@Validpublic ValuesProvider getValuesProvider() {@@ -68,6 +70,7 @@ public class ParamSupply implements Serializable {this.valuesProvider = valuesProvider;}+ @Editablepublic boolean isSecret() {return secret;}diff --git a/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/ScriptingValues.java b/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/ScriptingValues.javaindex 7b444a1033..8952c1d55a 100644--- a/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/ScriptingValues.java+++ b/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/ScriptingValues.java@@ -15,7 +15,7 @@ import io.onedev.server.util.GroovyUtils;import io.onedev.server.web.editable.annotation.Editable;import io.onedev.server.web.editable.annotation.ScriptChoice;-@Editable+@Editable(name="Evaluate script to get values or secrets")public class ScriptingValues implements ValuesProvider {private static final long serialVersionUID = 1L;diff --git a/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/SpecifiedValues.java b/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/SpecifiedValues.javaindex 0f5b6de541..808ca93964 100644--- a/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/SpecifiedValues.java+++ b/server-core/src/main/java/io/onedev/server/buildspec/job/paramsupply/SpecifiedValues.java@@ -8,7 +8,7 @@ import org.apache.commons.lang3.builder.HashCodeBuilder;import io.onedev.server.web.editable.annotation.Editable;-@Editable+@Editable(name="Use specified values or job secrets")public class SpecifiedValues implements ValuesProvider {private static final long serialVersionUID = 1L;@@ -19,6 +19,7 @@ public class SpecifiedValues implements ValuesProvider {private List<List<String>> values = new ArrayList<>();+ @Editable@Overridepublic List<List<String>> getValues() {return values;diff --git a/server-core/src/main/java/io/onedev/server/migration/VersionedXmlDoc.java b/server-core/src/main/java/io/onedev/server/migration/VersionedXmlDoc.javaindex 20fc05d708..0582a75602 100644--- a/server-core/src/main/java/io/onedev/server/migration/VersionedXmlDoc.java+++ b/server-core/src/main/java/io/onedev/server/migration/VersionedXmlDoc.java@@ -452,7 +452,8 @@ public final class VersionedXmlDoc implements Document, Externalizable {* to reflect current migration result.* @return*/- public Object toBean(Class<?> beanClass) {+ @SuppressWarnings("unchecked")+ public <T> T toBean(@Nullable Class<T> beanClass) {XStream xstream = AppLoader.getInstance(XStream.class);Dom4JReader domReader = new Dom4JReader(this);Class<?> origBeanClass;@@ -468,10 +469,10 @@ public final class VersionedXmlDoc implements Document, Externalizable {if (origBeanClass == null)return null;else if (origBeanClass == Null.class)- return ObjectUtils.NULL;+ return (T) ObjectUtils.NULL;if (beanClass == null)- beanClass = origBeanClass;+ beanClass = (Class<T>) origBeanClass;elsegetRootElement().setName(xstream.getMapper().serializedClass(beanClass));if (getVersion() != null) {@@ -480,15 +481,15 @@ public final class VersionedXmlDoc implements Document, Externalizable {if (MigrationHelper.migrate(getVersion(), migrator, this)) {setVersion(MigrationHelper.getVersion(migrator.getClass()));Object bean = xstream.unmarshal(domReader);- return bean;+ return (T) bean;} else {- return xstream.unmarshal(domReader);+ return (T) xstream.unmarshal(domReader);}} catch (InstantiationException | IllegalAccessException e) {throw new RuntimeException(e);}} else {- return xstream.unmarshal(domReader);+ return (T) xstream.unmarshal(domReader);}}diff --git a/server-core/src/main/java/io/onedev/server/migration/VersionedYamlDoc.java b/server-core/src/main/java/io/onedev/server/migration/VersionedYamlDoc.javaindex 9b49172297..370d428d79 100644--- a/server-core/src/main/java/io/onedev/server/migration/VersionedYamlDoc.java+++ b/server-core/src/main/java/io/onedev/server/migration/VersionedYamlDoc.java@@ -1,5 +1,7 @@package io.onedev.server.migration;+import java.beans.IntrospectionException;+import java.beans.PropertyDescriptor;import java.io.IOException;import java.io.StringReader;import java.io.StringWriter;@@ -21,6 +23,7 @@ import org.yaml.snakeyaml.Yaml;import org.yaml.snakeyaml.constructor.Constructor;import org.yaml.snakeyaml.emitter.Emitter;import org.yaml.snakeyaml.introspector.BeanAccess;+import org.yaml.snakeyaml.introspector.MethodProperty;import org.yaml.snakeyaml.introspector.Property;import org.yaml.snakeyaml.introspector.PropertyUtils;import org.yaml.snakeyaml.nodes.MappingNode;@@ -35,11 +38,9 @@ import org.yaml.snakeyaml.serializer.Serializer;import edu.emory.mathcs.backport.java.util.Collections;import io.onedev.commons.launcher.loader.ImplementationRegistry;import io.onedev.commons.utils.ClassUtils;-import io.onedev.commons.utils.StringUtils;import io.onedev.server.OneDev;import io.onedev.server.OneException;import io.onedev.server.util.BeanUtils;-import io.onedev.server.web.editable.EditableUtils;import io.onedev.server.web.editable.annotation.Editable;public class VersionedYamlDoc extends MappingNode {@@ -134,7 +135,7 @@ public class VersionedYamlDoc extends MappingNode {if (type.getAnnotation(Editable.class) != null && !ClassUtils.isConcrete(type)) {ImplementationRegistry registry = OneDev.getInstance(ImplementationRegistry.class);for (Class<?> implementationClass: registry.getImplementations(node.getType())) {- String implementationTag = new Tag(getTagValue(implementationClass)).getValue();+ String implementationTag = new Tag("!" + implementationClass.getSimpleName()).getValue();if (implementationTag.equals(node.getTag().getValue()))return implementationClass;}@@ -145,16 +146,16 @@ public class VersionedYamlDoc extends MappingNode {}- private static String getTagValue(Class<?> type) {- String displayName = EditableUtils.getDisplayName(type).toLowerCase();- return "!" + StringUtils.replace(displayName, " ", "-");- }-private static class OneYaml extends Yaml {OneYaml() {super(newConstructor(), newRepresenter());- setBeanAccess(BeanAccess.FIELD);++ /*+ * Use property here as yaml will be read by human and we want to make+ * it consistent with presented in UI+ */+ setBeanAccess(BeanAccess.PROPERTY);}private static Representer newRepresenter() {@@ -173,50 +174,38 @@ public class VersionedYamlDoc extends MappingNode {}}- @Override- protected Tag getTag(Class<?> clazz, Tag defaultTag) {- return super.getTag(clazz, defaultTag);- }-- @Override- protected MappingNode representJavaBean(Set<Property> properties, Object javaBean) {- if (javaBean.getClass().getAnnotation(Editable.class) != null)- classTags.put(javaBean.getClass(), new Tag(getTagValue(javaBean.getClass())));- return super.representJavaBean(properties, javaBean);- }-};representer.setDefaultFlowStyle(FlowStyle.BLOCK);representer.setPropertyUtils(new PropertyUtils() {@Overrideprotected Set<Property> createPropertySet(Class<? extends Object> type, BeanAccess bAccess) {+ List<Property> properties = new ArrayList<>();Map<String, Integer> orders = new HashMap<>();if (type.getAnnotation(Editable.class) != null) {for (Method getter: BeanUtils.findGetters(type)) {Editable editable = getter.getAnnotation(Editable.class);- if (editable != null)- orders.put(BeanUtils.getPropertyName(getter), editable.order());+ Method setter = BeanUtils.findSetter(getter);+ if (editable != null && setter != null) {+ String propertyName = BeanUtils.getPropertyName(getter);+ try {+ properties.add(new MethodProperty(new PropertyDescriptor(propertyName, getter, setter)));+ } catch (IntrospectionException e) {+ throw new RuntimeException(e);+ }+ orders.put(propertyName, editable.order());+ }}}- Set<Property> properties = super.createPropertySet(type, bAccess);- List<Property> listOfProperties = new ArrayList<>(properties);- Collections.sort(listOfProperties, new Comparator<Property>() {+ Collections.sort(properties, new Comparator<Property>() {- private int getOrder(Property property) {- Integer order = orders.get(property.getName());- if (order == null)- order = Integer.MAX_VALUE;- return order;- }-@Overridepublic int compare(Property o1, Property o2) {- return getOrder(o1) - getOrder(o2);+ return orders.get(o1.getName()) - orders.get(o2.getName());}});- return new LinkedHashSet<>(listOfProperties);+ return new LinkedHashSet<>(properties);}});diff --git a/server-core/src/main/java/io/onedev/server/migration/XmlBuildSpecMigrator.java b/server-core/src/main/java/io/onedev/server/migration/XmlBuildSpecMigrator.javanew file mode 100644index 0000000000..5fecc3ed5c--- /dev/null+++ b/server-core/src/main/java/io/onedev/server/migration/XmlBuildSpecMigrator.java@@ -0,0 +1,716 @@+package io.onedev.server.migration;++import java.io.IOException;+import java.io.StringReader;+import java.io.StringWriter;+import java.util.ArrayList;+import java.util.List;++import org.dom4j.Document;+import org.dom4j.DocumentException;+import org.dom4j.Element;+import org.dom4j.io.SAXReader;+import org.yaml.snakeyaml.DumperOptions;+import org.yaml.snakeyaml.DumperOptions.FlowStyle;+import org.yaml.snakeyaml.emitter.Emitter;+import org.yaml.snakeyaml.nodes.MappingNode;+import org.yaml.snakeyaml.nodes.Node;+import org.yaml.snakeyaml.nodes.NodeTuple;+import org.yaml.snakeyaml.nodes.ScalarNode;+import org.yaml.snakeyaml.nodes.SequenceNode;+import org.yaml.snakeyaml.nodes.Tag;+import org.yaml.snakeyaml.resolver.Resolver;+import org.yaml.snakeyaml.serializer.Serializer;++import com.google.common.collect.Lists;++import io.onedev.commons.utils.StringUtils;++public class XmlBuildSpecMigrator {++ private static Node migrateParamSpec(Element paramSpecElement) {+ String classTag = getClassTag(paramSpecElement.getName());+ List<NodeTuple> tuples = new ArrayList<>();+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "name"),+ new ScalarNode(Tag.STR, paramSpecElement.elementText("name").trim())));+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "allowEmpty"),+ new ScalarNode(Tag.STR, paramSpecElement.elementText("allowEmpty").trim())));+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "allowMultiple"),+ new ScalarNode(Tag.STR, paramSpecElement.elementText("allowMultiple").trim())));+ Element patternElement = paramSpecElement.element("pattern");+ if (patternElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "pattern"),+ new ScalarNode(Tag.STR, patternElement.getText().trim())));+ }+ Element descriptionElement = paramSpecElement.element("description");+ if (descriptionElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "description"),+ new ScalarNode(Tag.STR, descriptionElement.getText().trim())));+ }+ Element minValueElement = paramSpecElement.element("minValue");+ if (minValueElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "minValue"),+ new ScalarNode(Tag.STR, minValueElement.getText().trim())));+ }+ Element maxValueElement = paramSpecElement.element("maxValue");+ if (maxValueElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "maxValue"),+ new ScalarNode(Tag.STR, maxValueElement.getText().trim())));+ }+ Element showConditionElement = paramSpecElement.element("showCondition");+ if (showConditionElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "showCondition"),+ migrateShowCondition(showConditionElement)));+ }+ Element defaultValueProviderElement = paramSpecElement.element("defaultValueProvider");+ if (defaultValueProviderElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "defaultValueProvider"),+ migrateDefaultValueProvider(defaultValueProviderElement)));+ }+ Element defaultMultiValueProviderElement = paramSpecElement.element("defaultMultiValueProvider");+ if (defaultMultiValueProviderElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "defaultMultiValueProvider"),+ migrateDefaultMultiValueProvider(defaultMultiValueProviderElement)));+ }+ Element choiceProviderElement = paramSpecElement.element("choiceProvider");+ if (choiceProviderElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "choiceProvider"),+ migrateChoiceProvider(choiceProviderElement)));+ }+ return new MappingNode(new Tag(classTag), tuples, FlowStyle.BLOCK);+ }++ private static String getClassTag(String className) {+ return "!" + StringUtils.substringAfterLast(className, ".");+ }++ private static Node migrateChoiceProvider(Element choiceProviderElement) {+ List<NodeTuple> tuples = new ArrayList<>();+ String classTag = getClassTag(choiceProviderElement.attributeValue("class"));++ Element scriptNameElement = choiceProviderElement.element("scriptName");+ if (scriptNameElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "scriptName"),+ new ScalarNode(Tag.STR, scriptNameElement.getText().trim())));+ }+ Element choicesElement = choiceProviderElement.element("choices");+ if (choicesElement != null) {+ List<Node> choiceNodes = new ArrayList<>();+ for (Element choiceElement: choicesElement.elements()) {+ List<NodeTuple> choiceTuples = new ArrayList<>();+ choiceTuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "value"),+ new ScalarNode(Tag.STR, choiceElement.elementText("value").trim())));+ choiceTuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "color"),+ new ScalarNode(Tag.STR, choiceElement.elementText("color").trim())));+ choiceNodes.add(new MappingNode(Tag.MAP, choiceTuples, FlowStyle.BLOCK));+ }+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "choices"),+ new SequenceNode(Tag.SEQ, choiceNodes, FlowStyle.BLOCK)));+ }++ return new MappingNode(new Tag(classTag), tuples, FlowStyle.BLOCK);+ }++ private static Node migrateDefaultMultiValueProvider(Element defaultMultiValueProviderElement) {+ List<NodeTuple> tuples = new ArrayList<>();+ String classTag = getClassTag(defaultMultiValueProviderElement.attributeValue("class"));+ Element scriptNameElement = defaultMultiValueProviderElement.element("scriptName");+ if (scriptNameElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "scriptName"),+ new ScalarNode(Tag.STR, scriptNameElement.getText().trim())));+ }+ Element valueElement = defaultMultiValueProviderElement.element("value");+ if (valueElement != null) {+ List<Node> valueItemNodes = new ArrayList<>();+ for (Element valueItemElement: valueElement.elements())+ valueItemNodes.add(new ScalarNode(Tag.STR, valueItemElement.getText().trim()));+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "value"),+ new SequenceNode(Tag.SEQ, valueItemNodes, FlowStyle.BLOCK)));+ }++ return new MappingNode(new Tag(classTag), tuples, FlowStyle.BLOCK);+ }++ private static Node migrateDefaultValueProvider(Element defaultValueProviderElement) {+ List<NodeTuple> tuples = new ArrayList<>();+ String classTag = getClassTag(defaultValueProviderElement.attributeValue("class"));+ Element scriptNameElement = defaultValueProviderElement.element("scriptName");+ if (scriptNameElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "scriptName"),+ new ScalarNode(Tag.STR, scriptNameElement.getText().trim())));+ }+ Element valueElement = defaultValueProviderElement.element("value");+ if (valueElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "value"),+ new ScalarNode(Tag.STR, valueElement.getText().trim())));+ }++ return new MappingNode(new Tag(classTag), tuples, FlowStyle.BLOCK);+ }++ private static Node migrateShowCondition(Element showConditionElement) {+ List<NodeTuple> tuples = new ArrayList<>();+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "inputName"),+ new ScalarNode(Tag.STR, showConditionElement.elementText("inputName").trim())));+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "valueMatcher"),+ migrateValueMatcher(showConditionElement.element("valueMatcher"))));+ return new MappingNode(Tag.MAP, tuples, FlowStyle.BLOCK);+ }++ private static Node migrateValueMatcher(Element valueMatcherElement) {+ List<NodeTuple> tuples = new ArrayList<>();+ String classTag = getClassTag(valueMatcherElement.attributeValue("class"));+ Element valuesElement = valueMatcherElement.element("values");+ if (valuesElement != null) {+ List<Node> valueNodes = new ArrayList<>();+ for (Element valueElement: valuesElement.elements())+ valueNodes.add(new ScalarNode(Tag.STR, valueElement.getText().trim()));+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "values"),+ new SequenceNode(Tag.SEQ, valueNodes, FlowStyle.BLOCK)));+ }++ return new MappingNode(new Tag(classTag), tuples, FlowStyle.BLOCK);+ }++ private static Node migrateJob(Element jobElement) {+ List<NodeTuple> tuples = new ArrayList<>();+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "name"),+ new ScalarNode(Tag.STR, jobElement.elementText("name").trim())));+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "image"),+ new ScalarNode(Tag.STR, jobElement.elementText("image").trim())));+ List<Node> commandNodes = new ArrayList<>();+ for (Element commandElement: jobElement.element("commands").elements())+ commandNodes.add(new ScalarNode(Tag.STR, commandElement.getText().trim()));+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "commands"),+ new SequenceNode(Tag.SEQ, commandNodes, FlowStyle.BLOCK)));++ List<Node> paramSpecNodes = new ArrayList<>();+ for (Element paramSpecElement: jobElement.element("paramSpecs").elements())+ paramSpecNodes.add(migrateParamSpec(paramSpecElement));++ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "paramSpecs"),+ new SequenceNode(Tag.SEQ, paramSpecNodes, FlowStyle.BLOCK)));++ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "retrieveSource"),+ new ScalarNode(Tag.STR, jobElement.elementText("retrieveSource").trim())));+ Element cloneDepthElement = jobElement.element("cloneDepth");+ if (cloneDepthElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "cloneDepth"),+ new ScalarNode(Tag.STR, cloneDepthElement.getText().trim())));+ }++ List<Node> submoduleCredentialNodes = new ArrayList<>();+ for (Element submoduleCredentialElement: jobElement.element("submoduleCredentials").elements()) {+ List<NodeTuple> submoduleCredentialTuples = new ArrayList<>();+ submoduleCredentialTuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "url"),+ new ScalarNode(Tag.STR, submoduleCredentialElement.elementText("url").trim())));+ submoduleCredentialTuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "userName"),+ new ScalarNode(Tag.STR, submoduleCredentialElement.elementText("userName").trim())));+ submoduleCredentialTuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "passwordSecret"),+ new ScalarNode(Tag.STR, submoduleCredentialElement.elementText("passwordSecret").trim())));+ submoduleCredentialNodes.add(new MappingNode(Tag.MAP, submoduleCredentialTuples, FlowStyle.BLOCK));+ }+ if (!submoduleCredentialNodes.isEmpty()) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "submoduleCredentials"),+ new SequenceNode(Tag.SEQ, submoduleCredentialNodes, FlowStyle.BLOCK)));+ }++ List<Node> jobDependencyNodes = new ArrayList<>();+ for (Element jobDependencyElement: jobElement.element("jobDependencies").elements())+ jobDependencyNodes.add(migrateJobDependency(jobDependencyElement));+ if (!jobDependencyNodes.isEmpty()) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "jobDependencies"),+ new SequenceNode(Tag.SEQ, jobDependencyNodes, FlowStyle.BLOCK)));+ }++ List<Node> projectDependencyNodes = new ArrayList<>();+ for (Element projectDependencyElement: jobElement.element("projectDependencies").elements())+ projectDependencyNodes.add(migrateProjectDependency(projectDependencyElement));+ if (!projectDependencyNodes.isEmpty()) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "projectDependencies"),+ new SequenceNode(Tag.SEQ, projectDependencyNodes, FlowStyle.BLOCK)));+ }++ List<Node> serviceNodes = new ArrayList<>();+ for (Element serviceElement: jobElement.element("services").elements())+ serviceNodes.add(migrateService(serviceElement));+ if (!serviceNodes.isEmpty()) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "services"),+ new SequenceNode(Tag.SEQ, serviceNodes, FlowStyle.BLOCK)));+ }++ Element artifactsElement = jobElement.element("artifacts");+ if (artifactsElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "artifacts"),+ new ScalarNode(Tag.STR, artifactsElement.getText().trim())));+ }++ List<Node> reportNodes = new ArrayList<>();+ for (Element reportElement: jobElement.element("reports").elements())+ reportNodes.add(migrateReport(reportElement));+ if (!reportNodes.isEmpty()) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "reports"),+ new SequenceNode(Tag.SEQ, reportNodes, FlowStyle.BLOCK)));+ }++ List<Node> triggerNodes = new ArrayList<>();+ for (Element triggerElement: jobElement.element("triggers").elements())+ triggerNodes.add(migrateTrigger(triggerElement));+ if (!triggerNodes.isEmpty()) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "triggers"),+ new SequenceNode(Tag.SEQ, triggerNodes, FlowStyle.BLOCK)));+ }++ List<Node> cacheNodes = new ArrayList<>();+ for (Element cacheElement: jobElement.element("caches").elements())+ cacheNodes.add(migrateCache(cacheElement));+ if (!cacheNodes.isEmpty()) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "caches"),+ new SequenceNode(Tag.SEQ, cacheNodes, FlowStyle.BLOCK)));+ }++ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "cpuRequirement"),+ new ScalarNode(Tag.STR, jobElement.elementText("cpuRequirement").trim())));+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "memoryRequirement"),+ new ScalarNode(Tag.STR, jobElement.elementText("memoryRequirement").trim())));+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "timeout"),+ new ScalarNode(Tag.STR, jobElement.elementText("timeout").trim())));++ List<Node> postBuildActionNodes = new ArrayList<>();+ for (Element postBuildActionElement: jobElement.element("postBuildActions").elements())+ postBuildActionNodes.add(migratePostBuildAction(postBuildActionElement));+ if (!postBuildActionNodes.isEmpty()) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "postBuildActions"),+ new SequenceNode(Tag.SEQ, postBuildActionNodes, FlowStyle.BLOCK)));+ }++ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "retryCondition"),+ new ScalarNode(Tag.STR, jobElement.elementText("retryCondition").trim())));+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "maxRetries"),+ new ScalarNode(Tag.STR, jobElement.elementText("maxRetries").trim())));+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "retryDelay"),+ new ScalarNode(Tag.STR, jobElement.elementText("retryDelay").trim())));++ Element defaultFixedIssuesFilterElement = jobElement.element("defaultFixedIssuesFilter");+ if (defaultFixedIssuesFilterElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "defaultFixedIssuesFilter"),+ new ScalarNode(Tag.STR, defaultFixedIssuesFilterElement.getText().trim())));+ }++ MappingNode jobNode = new MappingNode(Tag.MAP, tuples, FlowStyle.BLOCK);+ return jobNode;+ }++ private static Node migratePostBuildAction(Element postBuildActionElement) {+ List<NodeTuple> tuples = new ArrayList<>();+ String classTag = getClassTag(postBuildActionElement.getName());++ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "condition"),+ new ScalarNode(Tag.STR, postBuildActionElement.elementText("condition").trim())));++ Element milestoneNameElement = postBuildActionElement.element("milestoneName");+ if (milestoneNameElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "milestoneName"),+ new ScalarNode(Tag.STR, milestoneNameElement.getText().trim())));+ }++ Element issueTitleElement = postBuildActionElement.element("issueTitle");+ if (issueTitleElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "issueTitle"),+ new ScalarNode(Tag.STR, issueTitleElement.getText().trim())));+ }++ Element issueDescriptionElement = postBuildActionElement.element("issueDescription");+ if (issueDescriptionElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "issueDescription"),+ new ScalarNode(Tag.STR, issueDescriptionElement.getText().trim())));+ }++ Element issueFieldsElement = postBuildActionElement.element("issueFields");+ if (issueFieldsElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "issueFields"),+ new SequenceNode(Tag.SEQ, migrateFieldSupplies(issueFieldsElement.elements()), FlowStyle.BLOCK)));+ }++ Element tagNameElement = postBuildActionElement.element("tagName");+ if (tagNameElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "tagName"),+ new ScalarNode(Tag.STR, tagNameElement.getText().trim())));+ }++ Element tagMessageElement = postBuildActionElement.element("tagMessage");+ if (tagMessageElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "tagMessage"),+ new ScalarNode(Tag.STR, tagMessageElement.getText().trim())));+ }++ Element jobNameElement = postBuildActionElement.element("jobName");+ if (jobNameElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "jobName"),+ new ScalarNode(Tag.STR, jobNameElement.getText().trim())));+ }++ Element jobParamsElement = postBuildActionElement.element("jobParams");+ if (jobParamsElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "jobParams"),+ new SequenceNode(Tag.SEQ, migrateParamSupplies(jobParamsElement.elements()), FlowStyle.BLOCK)));+ }++ Element receiversElement = postBuildActionElement.element("receivers");+ if (receiversElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "receivers"),+ new ScalarNode(Tag.STR, receiversElement.getText().trim())));+ }++ return new MappingNode(new Tag(classTag), tuples, FlowStyle.BLOCK);+ }++ private static Node migrateCache(Element cacheElement) {+ List<NodeTuple> tuples = new ArrayList<>();+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "key"),+ new ScalarNode(Tag.STR, cacheElement.elementText("key").trim())));+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "path"),+ new ScalarNode(Tag.STR, cacheElement.elementText("path").trim())));+ return new MappingNode(Tag.MAP, tuples, FlowStyle.BLOCK);+ }++ private static Node migrateTrigger(Element triggerElement) {+ List<NodeTuple> tuples = new ArrayList<>();+ String classTag = getClassTag(triggerElement.getName());++ List<Node> paramSupplyNodes = migrateParamSupplies(triggerElement.element("params").elements());+ if (!paramSupplyNodes.isEmpty()) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "params"),+ new SequenceNode(Tag.SEQ, paramSupplyNodes, FlowStyle.BLOCK)));+ }++ Element branchesElement = triggerElement.element("branches");+ if (branchesElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "branches"),+ new ScalarNode(Tag.STR, branchesElement.getText().trim())));+ }++ Element pathsElement = triggerElement.element("paths");+ if (pathsElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "paths"),+ new ScalarNode(Tag.STR, pathsElement.getText().trim())));+ }++ Element tagsElement = triggerElement.element("tags");+ if (tagsElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "tags"),+ new ScalarNode(Tag.STR, tagsElement.getText().trim())));+ }++ return new MappingNode(new Tag(classTag), tuples, FlowStyle.BLOCK);+ }++ private static Node migrateReport(Element reportElement) {+ List<NodeTuple> tuples = new ArrayList<>();+ String classTag = getClassTag(reportElement.getName());+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "filePatterns"),+ new ScalarNode(Tag.STR, reportElement.elementText("filePatterns").trim())));+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "reportName"),+ new ScalarNode(Tag.STR, reportElement.elementText("reportName").trim())));+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "startPage"),+ new ScalarNode(Tag.STR, reportElement.elementText("startPage").trim())));+ return new MappingNode(new Tag(classTag), tuples, FlowStyle.BLOCK);+ }++ private static Node migrateService(Element serviceElement) {+ List<NodeTuple> tuples = new ArrayList<>();++ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "name"),+ new ScalarNode(Tag.STR, serviceElement.elementText("name").trim())));+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "image"),+ new ScalarNode(Tag.STR, serviceElement.elementText("image").trim())));+ Element argumentsElement = serviceElement.element("arguments");+ if (argumentsElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "arguments"),+ new ScalarNode(Tag.STR, argumentsElement.getText().trim())));+ }+ List<Node> envVarNodes = new ArrayList<>();+ for (Element envVarElement: serviceElement.element("envVars").elements()) {+ List<NodeTuple> envVarTuples = new ArrayList<>();+ envVarTuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "name"),+ new ScalarNode(Tag.STR, envVarElement.elementText("name").trim())));+ envVarTuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "value"),+ new ScalarNode(Tag.STR, envVarElement.elementText("value").trim())));+ envVarNodes.add(new MappingNode(Tag.MAP, envVarTuples, FlowStyle.BLOCK));+ }+ if (!envVarNodes.isEmpty()) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "envVars"),+ new SequenceNode(Tag.SEQ, envVarNodes, FlowStyle.BLOCK)));+ }+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "readinessCheckCommand"),+ new ScalarNode(Tag.STR, serviceElement.elementText("readinessCheckCommand").trim())));+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "cpuRequirement"),+ new ScalarNode(Tag.STR, serviceElement.elementText("cpuRequirement").trim())));+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "memoryRequirement"),+ new ScalarNode(Tag.STR, serviceElement.elementText("memoryRequirement").trim())));++ return new MappingNode(Tag.MAP, tuples, FlowStyle.BLOCK);+ }++ private static Node migrateProjectDependency(Element projectDependencyElement) {+ List<NodeTuple> tuples = new ArrayList<>();+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "projectName"),+ new ScalarNode(Tag.STR, projectDependencyElement.elementText("projectName").trim())));+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "buildNumber"),+ new ScalarNode(Tag.STR, projectDependencyElement.elementText("buildNumber").trim())));+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "artifacts"),+ new ScalarNode(Tag.STR, projectDependencyElement.elementText("artifacts").trim())));++ Element authenticationElement = projectDependencyElement.element("authentication");+ if (authenticationElement != null) {+ List<NodeTuple> authenticationTuples = new ArrayList<>();+ authenticationTuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "userName"),+ new ScalarNode(Tag.STR, authenticationElement.elementText("userName").trim())));+ authenticationTuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "passwordSecret"),+ new ScalarNode(Tag.STR, authenticationElement.elementText("passwordSecret").trim())));+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "authentication"),+ new MappingNode(Tag.MAP, authenticationTuples, FlowStyle.BLOCK)));+ }+ return new MappingNode(Tag.MAP, tuples, FlowStyle.BLOCK);+ }++ private static Node migrateJobDependency(Element jobDependencyElement) {+ List<NodeTuple> tuples = new ArrayList<>();+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "jobName"),+ new ScalarNode(Tag.STR, jobDependencyElement.elementText("jobName").trim())));+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "requireSuccessful"),+ new ScalarNode(Tag.STR, jobDependencyElement.elementText("requireSuccessful").trim())));+ Element artifactsElement = jobDependencyElement.element("artifacts");+ if (artifactsElement != null) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "artifacts"),+ new ScalarNode(Tag.STR, artifactsElement.getText().trim())));+ }++ List<Node> paramSupplyNodes = migrateParamSupplies(jobDependencyElement.element("jobParams").elements());+ if (!paramSupplyNodes.isEmpty()) {+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "jobParams"),+ new SequenceNode(Tag.SEQ, paramSupplyNodes, FlowStyle.BLOCK)));+ }+ return new MappingNode(Tag.MAP, tuples, FlowStyle.BLOCK);+ }++ private static List<Node> migrateParamSupplies(List<Element> paramSupplyElements) {+ List<Node> paramSupplyNodes = new ArrayList<>();+ for (Element paramSupplyElement: paramSupplyElements) {+ List<NodeTuple> tuples = new ArrayList<>();+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "name"),+ new ScalarNode(Tag.STR, paramSupplyElement.elementText("name").trim())));+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "secret"),+ new ScalarNode(Tag.STR, paramSupplyElement.elementText("secret").trim())));++ Element valuesProviderElement = paramSupplyElement.element("valuesProvider");+ String classTag = getClassTag(valuesProviderElement.attributeValue("class"));+ List<NodeTuple> valuesProviderTuples = new ArrayList<>();+ Element scriptNameElement = valuesProviderElement.element("scriptName");+ if (scriptNameElement != null) {+ valuesProviderTuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "scriptName"),+ new ScalarNode(Tag.STR, scriptNameElement.getText().trim())));+ }+ Element valuesElement = valuesProviderElement.element("values");+ if (valuesElement != null) {+ List<Node> listNodes = new ArrayList<>();+ for (Element listElement: valuesElement.elements()) {+ List<Node> listItemNodes = new ArrayList<>();+ for (Element listItemElement: listElement.elements())+ listItemNodes.add(new ScalarNode(Tag.STR, listItemElement.getText().trim()));+ listNodes.add(new SequenceNode(Tag.SEQ, listItemNodes, FlowStyle.BLOCK));+ }+ valuesProviderTuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "values"),+ new SequenceNode(Tag.SEQ, listNodes, FlowStyle.BLOCK)));+ }++ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "valuesProvider"),+ new MappingNode(new Tag(classTag), valuesProviderTuples, FlowStyle.BLOCK)));+ paramSupplyNodes.add(new MappingNode(Tag.MAP, tuples, FlowStyle.BLOCK));+ }+ return paramSupplyNodes;+ }++ private static List<Node> migrateFieldSupplies(List<Element> fieldSupplyElements) {+ List<Node> fieldSupplyNodes = new ArrayList<>();+ for (Element fieldSupplyElement: fieldSupplyElements) {+ List<NodeTuple> tuples = new ArrayList<>();+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "name"),+ new ScalarNode(Tag.STR, fieldSupplyElement.elementText("name").trim())));+ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "secret"),+ new ScalarNode(Tag.STR, fieldSupplyElement.elementText("secret").trim())));++ Element valueProviderElement = fieldSupplyElement.element("valueProvider");+ String classTag = getClassTag(valueProviderElement.attributeValue("class"));+ List<NodeTuple> valueProviderTuples = new ArrayList<>();+ Element scriptNameElement = valueProviderElement.element("scriptName");+ if (scriptNameElement != null) {+ valueProviderTuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "scriptName"),+ new ScalarNode(Tag.STR, scriptNameElement.getText().trim())));+ }+ Element valueElement = valueProviderElement.element("value");+ if (valueElement != null) {+ List<Node> valueItemNodes = new ArrayList<>();+ for (Element valueItemElement: valueElement.elements())+ valueItemNodes.add(new ScalarNode(Tag.STR, valueItemElement.getText().trim()));+ valueProviderTuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "value"),+ new SequenceNode(Tag.SEQ, valueItemNodes, FlowStyle.BLOCK)));+ }++ tuples.add(new NodeTuple(+ new ScalarNode(Tag.STR, "valueProvider"),+ new MappingNode(new Tag(classTag), valueProviderTuples, FlowStyle.BLOCK)));+ fieldSupplyNodes.add(new MappingNode(Tag.MAP, tuples, FlowStyle.BLOCK));+ }+ return fieldSupplyNodes;+ }++ public static String migrate(String xml) {+ Document xmlDoc;+ try {+ xmlDoc = new SAXReader().read(new StringReader(xml));+ } catch (DocumentException e) {+ throw new RuntimeException(e);+ }++ List<NodeTuple> tuples = new ArrayList<>();+ Node keyNode = new ScalarNode(Tag.STR, "version");+ Node valueNode = new ScalarNode(Tag.INT, "0");+ tuples.add(new NodeTuple(keyNode, valueNode));++ List<Node> jobNodes = new ArrayList<>();+ for (Element jobElement: xmlDoc.getRootElement().element("jobs").elements())+ jobNodes.add(migrateJob(jobElement));++ if (!jobNodes.isEmpty()) {+ keyNode = new ScalarNode(Tag.STR, "jobs");+ tuples.add(new NodeTuple(keyNode, new SequenceNode(Tag.SEQ, jobNodes, FlowStyle.BLOCK)));+ }++ List<Node> propertyNodes = new ArrayList<>();+ Element propertiesElement = xmlDoc.getRootElement().element("properties");+ if (propertiesElement != null) {+ for (Element propertyElement: propertiesElement.elements()) {+ Node nameNode = new ScalarNode(Tag.STR, propertyElement.elementText("name").trim());+ valueNode = new ScalarNode(Tag.STR, propertyElement.elementText("value").trim());+ List<NodeTuple> propertyTuples = Lists.newArrayList(+ new NodeTuple(new ScalarNode(Tag.STR, "name"), nameNode),+ new NodeTuple(new ScalarNode(Tag.STR, "value"), valueNode));+ propertyNodes.add(new MappingNode(Tag.MAP, propertyTuples, FlowStyle.BLOCK));+ }+ }+ if(!propertyNodes.isEmpty()) {+ keyNode = new ScalarNode(Tag.STR, "properties");+ tuples.add(new NodeTuple(keyNode, new SequenceNode(Tag.SEQ, propertyNodes, FlowStyle.BLOCK)));+ }++ MappingNode rootNode = new MappingNode(Tag.MAP, tuples, FlowStyle.BLOCK);+ StringWriter writer = new StringWriter();+ DumperOptions dumperOptions = new DumperOptions();+ Serializer serializer = new Serializer(new Emitter(writer, dumperOptions),+ new Resolver(), dumperOptions, Tag.MAP);+ try {+ serializer.open();+ serializer.serialize(rootNode);+ serializer.close();+ return writer.toString();+ } catch (IOException e) {+ throw new RuntimeException(e);+ }++ }+}diff --git a/server-core/src/main/java/io/onedev/server/model/Project.java b/server-core/src/main/java/io/onedev/server/model/Project.javaindex 69a282fa85..aab8ecfa94 100644--- a/server-core/src/main/java/io/onedev/server/model/Project.java+++ b/server-core/src/main/java/io/onedev/server/model/Project.java@@ -695,10 +695,15 @@ public class Project extends AbstractEntity {Optional<BuildSpec> buildSpec = buildSpecCache.get(commitId);if (buildSpec == null) {Blob blob = getBlob(new BlobIdent(commitId.name(), BuildSpec.BLOB_PATH, FileMode.TYPE_FILE), false);- if (blob != null)+ if (blob != null) {buildSpec = Optional.fromNullable(BuildSpec.parse(blob.getBytes()));- else- buildSpec = Optional.absent();+ } else {+ Blob oldBlob = getBlob(new BlobIdent(commitId.name(), ".onedev-buildspec", FileMode.TYPE_FILE), false);+ if (oldBlob != null)+ buildSpec = Optional.fromNullable(BuildSpec.parse(oldBlob.getBytes()));+ else+ buildSpec = Optional.absent();+ }buildSpecCache.put(commitId, buildSpec);}return buildSpec.orNull();diff --git a/server-core/src/main/java/io/onedev/server/util/inputspec/choiceinput/defaultmultivalueprovider/SpecifiedDefaultMultiValue.java b/server-core/src/main/java/io/onedev/server/util/inputspec/choiceinput/defaultmultivalueprovider/SpecifiedDefaultMultiValue.javaindex df349eb67b..9093cdf02b 100755--- a/server-core/src/main/java/io/onedev/server/util/inputspec/choiceinput/defaultmultivalueprovider/SpecifiedDefaultMultiValue.java+++ b/server-core/src/main/java/io/onedev/server/util/inputspec/choiceinput/defaultmultivalueprovider/SpecifiedDefaultMultiValue.java@@ -15,7 +15,7 @@ import io.onedev.server.util.inputspec.choiceinput.choiceprovider.ChoiceProviderimport io.onedev.server.web.editable.annotation.Editable;import io.onedev.server.web.editable.annotation.OmitName;-@Editable(order=100, name="Specified default value")+@Editable(order=100, name="Use specified default value")public class SpecifiedDefaultMultiValue implements DefaultMultiValueProvider {private static final long serialVersionUID = 1L;diff --git a/server-core/src/main/java/io/onedev/server/util/inputspec/choiceinput/defaultvalueprovider/SpecifiedDefaultValue.java b/server-core/src/main/java/io/onedev/server/util/inputspec/choiceinput/defaultvalueprovider/SpecifiedDefaultValue.javaindex ddf6a2a9bd..eb8ea02e1b 100755--- a/server-core/src/main/java/io/onedev/server/util/inputspec/choiceinput/defaultvalueprovider/SpecifiedDefaultValue.java+++ b/server-core/src/main/java/io/onedev/server/util/inputspec/choiceinput/defaultvalueprovider/SpecifiedDefaultValue.java@@ -13,7 +13,7 @@ import io.onedev.server.util.inputspec.choiceinput.choiceprovider.ChoiceProviderimport io.onedev.server.web.editable.annotation.Editable;import io.onedev.server.web.editable.annotation.OmitName;-@Editable(order=100, name="Specified default value")+@Editable(order=100, name="Use specified default value")public class SpecifiedDefaultValue implements DefaultValueProvider {private static final long serialVersionUID = 1L;diff --git a/server-core/src/main/java/io/onedev/server/util/inputspec/groupchoiceinput/defaultvalueprovider/SpecifiedDefaultValue.java b/server-core/src/main/java/io/onedev/server/util/inputspec/groupchoiceinput/defaultvalueprovider/SpecifiedDefaultValue.javaindex 078a6cc9c7..d348348546 100755--- a/server-core/src/main/java/io/onedev/server/util/inputspec/groupchoiceinput/defaultvalueprovider/SpecifiedDefaultValue.java+++ b/server-core/src/main/java/io/onedev/server/util/inputspec/groupchoiceinput/defaultvalueprovider/SpecifiedDefaultValue.java@@ -16,7 +16,7 @@ import io.onedev.server.web.editable.annotation.Editable;import io.onedev.server.web.editable.annotation.GroupChoice;import io.onedev.server.web.editable.annotation.OmitName;-@Editable(order=100, name="Specified default value")+@Editable(order=100, name="Use specified default value")public class SpecifiedDefaultValue implements DefaultValueProvider {private static final long serialVersionUID = 1L;diff --git a/server-core/src/main/java/io/onedev/server/util/inputspec/userchoiceinput/choiceprovider/AllUsers.java b/server-core/src/main/java/io/onedev/server/util/inputspec/userchoiceinput/choiceprovider/AllUsers.javaindex 906d5355f5..f536f86bb5 100755--- a/server-core/src/main/java/io/onedev/server/util/inputspec/userchoiceinput/choiceprovider/AllUsers.java+++ b/server-core/src/main/java/io/onedev/server/util/inputspec/userchoiceinput/choiceprovider/AllUsers.java@@ -12,7 +12,7 @@ import io.onedev.server.web.editable.annotation.Editable;import io.onedev.server.web.page.project.issues.detail.IssueDetailPage;import io.onedev.server.web.util.WicketUtils;-@Editable(order=130, name="All users in system")+@Editable(order=130, name="All users")public class AllUsers implements ChoiceProvider {private static final long serialVersionUID = 1L;diff --git a/server-core/src/main/java/io/onedev/server/util/inputspec/userchoiceinput/defaultmultivalueprovider/SpecifiedDefaultMultiValue.java b/server-core/src/main/java/io/onedev/server/util/inputspec/userchoiceinput/defaultmultivalueprovider/SpecifiedDefaultMultiValue.javaindex ebd91e1708..51625dc571 100755--- a/server-core/src/main/java/io/onedev/server/util/inputspec/userchoiceinput/defaultmultivalueprovider/SpecifiedDefaultMultiValue.java+++ b/server-core/src/main/java/io/onedev/server/util/inputspec/userchoiceinput/defaultmultivalueprovider/SpecifiedDefaultMultiValue.java@@ -15,7 +15,7 @@ import io.onedev.server.web.editable.annotation.Editable;import io.onedev.server.web.editable.annotation.OmitName;import io.onedev.server.web.editable.annotation.UserChoice;-@Editable(order=100, name="Specified default value")+@Editable(order=100, name="Use specified default value")public class SpecifiedDefaultMultiValue implements DefaultMultiValueProvider {private static final long serialVersionUID = 1L;diff --git a/server-core/src/main/java/io/onedev/server/util/inputspec/userchoiceinput/defaultvalueprovider/SpecifiedDefaultValue.java b/server-core/src/main/java/io/onedev/server/util/inputspec/userchoiceinput/defaultvalueprovider/SpecifiedDefaultValue.javaindex 9949880684..93ea784b9a 100755--- a/server-core/src/main/java/io/onedev/server/util/inputspec/userchoiceinput/defaultvalueprovider/SpecifiedDefaultValue.java+++ b/server-core/src/main/java/io/onedev/server/util/inputspec/userchoiceinput/defaultvalueprovider/SpecifiedDefaultValue.java@@ -11,7 +11,7 @@ import io.onedev.server.web.editable.annotation.Editable;import io.onedev.server.web.editable.annotation.OmitName;import io.onedev.server.web.editable.annotation.UserChoice;-@Editable(order=100, name="Specified default value")+@Editable(order=100, name="Use specified default value")public class SpecifiedDefaultValue implements DefaultValueProvider {private static final long serialVersionUID = 1L;diff --git a/server-core/src/main/java/io/onedev/server/web/component/job/JobDefLink.java b/server-core/src/main/java/io/onedev/server/web/component/job/JobDefLink.javaindex a7de223fac..8224c40a2a 100644--- a/server-core/src/main/java/io/onedev/server/web/component/job/JobDefLink.java+++ b/server-core/src/main/java/io/onedev/server/web/component/job/JobDefLink.java@@ -46,6 +46,8 @@ public abstract class JobDefLink extends BookmarkablePageLink<Void> {public PageParameters getPageParameters() {ProjectBlobPage.State state = new ProjectBlobPage.State();state.blobIdent = new BlobIdent(commitId.name(), BuildSpec.BLOB_PATH, FileMode.REGULAR_FILE.getBits());+ if (getProject().getBlob(state.blobIdent, false) == null)+ state.blobIdent = new BlobIdent(commitId.name(), ".onedev-buildspec", FileMode.REGULAR_FILE.getBits());state.position = BuildSpecRendererProvider.getPosition(Job.SELECTION_PREFIX + jobName);return ProjectBlobPage.paramsOf(getProject(), state);}diff --git a/server-core/src/main/java/io/onedev/server/web/editable/date/DateEditSupport.java b/server-core/src/main/java/io/onedev/server/web/editable/date/DateEditSupport.javaindex e04f7486dd..dc15aefe00 100644--- a/server-core/src/main/java/io/onedev/server/web/editable/date/DateEditSupport.java+++ b/server-core/src/main/java/io/onedev/server/web/editable/date/DateEditSupport.java@@ -6,6 +6,7 @@ import org.apache.wicket.Component;import org.apache.wicket.markup.html.basic.Label;import org.apache.wicket.model.IModel;+import io.onedev.server.util.DateUtils;import io.onedev.server.web.editable.EditSupport;import io.onedev.server.web.editable.EmptyValueLabel;import io.onedev.server.web.editable.PropertyContext;@@ -32,7 +33,7 @@ public class DateEditSupport implements EditSupport {@Overrideprotected Component newContent(String id, PropertyDescriptor propertyDescriptor) {if (model.getObject() != null) {- return new Label(id, model.getObject());+ return new Label(id, DateUtils.formatDate(model.getObject()));} else {NameOfEmptyValue nameOfEmptyValue = propertyDescriptor.getPropertyGetter().getAnnotation(NameOfEmptyValue.class);if (nameOfEmptyValue != null)diff --git a/server-core/src/main/java/io/onedev/server/web/page/project/blob/ProjectBlobPage.java b/server-core/src/main/java/io/onedev/server/web/page/project/blob/ProjectBlobPage.javaindex 16305535b2..b5d4f1256a 100644--- a/server-core/src/main/java/io/onedev/server/web/page/project/blob/ProjectBlobPage.java+++ b/server-core/src/main/java/io/onedev/server/web/page/project/blob/ProjectBlobPage.java@@ -784,8 +784,9 @@ public class ProjectBlobPage extends ProjectPage implements BlobRenderContext, Sprotected void onConfigure() {super.onConfigure();if (resolvedRevision != null && isOnBranch() && state.blobIdent.path == null && state.mode == Mode.VIEW) {+ BlobIdent oldBlobIdent = new BlobIdent(resolvedRevision.name(), ".onedev-buildspec", FileMode.TYPE_FILE);BlobIdent blobIdent = new BlobIdent(resolvedRevision.name(), BuildSpec.BLOB_PATH, FileMode.TYPE_FILE);- setVisible(getProject().getBlob(blobIdent, false) == null);+ setVisible(getProject().getBlob(blobIdent, false) == null && getProject().getBlob(oldBlobIdent, false) == null);} else {setVisible(false);}diff --git a/server-core/src/main/java/io/onedev/server/web/page/project/blob/navigator/BlobNavigator.java b/server-core/src/main/java/io/onedev/server/web/page/project/blob/navigator/BlobNavigator.javaindex 8d8a9ceb93..8392ff5a19 100644--- a/server-core/src/main/java/io/onedev/server/web/page/project/blob/navigator/BlobNavigator.java+++ b/server-core/src/main/java/io/onedev/server/web/page/project/blob/navigator/BlobNavigator.java@@ -39,6 +39,7 @@ import org.eclipse.jgit.lib.FileMode;import com.google.common.base.Splitter;import io.onedev.commons.utils.StringUtils;+import io.onedev.server.buildspec.BuildSpec;import io.onedev.server.git.BlobIdent;import io.onedev.server.git.BlobIdentFilter;import io.onedev.server.git.GitUtils;@@ -254,6 +255,8 @@ public class BlobNavigator extends Panel {name = context.getInitialNewPath();else if (file.path.contains("/"))name = StringUtils.substringAfterLast(file.path, "/");+ else if (file.path.equals(".onedev-buildspec"))+ name = BuildSpec.BLOB_PATH;elsename = file.path;diff --git a/server-core/src/main/java/io/onedev/server/web/page/project/blob/render/edit/plain/plain-edit.js b/server-core/src/main/java/io/onedev/server/web/page/project/blob/render/edit/plain/plain-edit.jsindex cacb9e7816..1a50f72295 100644--- a/server-core/src/main/java/io/onedev/server/web/page/project/blob/render/edit/plain/plain-edit.js+++ b/server-core/src/main/java/io/onedev/server/web/page/project/blob/render/edit/plain/plain-edit.js@@ -6,11 +6,10 @@ onedev.server.plainEdit = {var cm = CodeMirror($source[0], {value: $plainEdit.children(".input").val(),theme: "eclipse",- indentWithTabs: true,+ indentWithTabs: false,indentUnit: 4,lineNumbers: true,lineWrapping: true,- tabSize: 4,styleActiveLine: true,styleSelectedText: true,foldGutter: true,diff --git a/server-core/src/main/java/io/onedev/server/web/page/project/blob/render/renderers/buildspec/BuildSpecRendererProvider.java b/server-core/src/main/java/io/onedev/server/web/page/project/blob/render/renderers/buildspec/BuildSpecRendererProvider.javaindex bf6b736bb0..dfefb702ea 100644--- a/server-core/src/main/java/io/onedev/server/web/page/project/blob/render/renderers/buildspec/BuildSpecRendererProvider.java+++ b/server-core/src/main/java/io/onedev/server/web/page/project/blob/render/renderers/buildspec/BuildSpecRendererProvider.java@@ -20,7 +20,7 @@ public class BuildSpecRendererProvider implements BlobRendererContribution {private static final String POSITION_PREFIX = "buildspec-";private boolean isBuildSpec(@Nullable String blobPath) {- return BuildSpec.BLOB_PATH.equals(blobPath);+ return BuildSpec.BLOB_PATH.equals(blobPath) || ".onedev-buildspec".equals(blobPath);}@Nullablediff --git a/server-core/src/main/java/io/onedev/server/web/page/project/blob/render/renderers/folder/FolderViewPanel.java b/server-core/src/main/java/io/onedev/server/web/page/project/blob/render/renderers/folder/FolderViewPanel.javaindex 10885d3858..427590d3df 100644--- a/server-core/src/main/java/io/onedev/server/web/page/project/blob/render/renderers/folder/FolderViewPanel.java+++ b/server-core/src/main/java/io/onedev/server/web/page/project/blob/render/renderers/folder/FolderViewPanel.java@@ -99,8 +99,14 @@ public class FolderViewPanel extends Panel {Collections.sort(children);+ BlobIdent oldBuildSpecIdent = new BlobIdent(context.getBlobIdent().revision,+ ".onedev-buildspec", FileMode.REGULAR_FILE.getBits());BlobIdent buildSpecIdent = new BlobIdent(context.getBlobIdent().revision,BuildSpec.BLOB_PATH, FileMode.REGULAR_FILE.getBits());+ if (children.contains(oldBuildSpecIdent)) {+ children.remove(oldBuildSpecIdent);+ children.add(0, oldBuildSpecIdent);+ }if (children.contains(buildSpecIdent)) {children.remove(buildSpecIdent);children.add(0, buildSpecIdent);@@ -210,7 +216,7 @@ public class FolderViewPanel extends Panel {iconClass = "fa fa-ext fa-folder-submodule-o";else if (blobIdent.isSymbolLink())iconClass = "fa fa-ext fa-folder-symbol-link-o";- else if (blobIdent.path.equals(BuildSpec.BLOB_PATH))+ else if (blobIdent.path.equals(BuildSpec.BLOB_PATH) || blobIdent.path.equals(".onedev-buildspec"))iconClass = "fa fa-cog";elseiconClass = "fa fa-file-text-o";@@ -220,7 +226,7 @@ public class FolderViewPanel extends Panel {if (context.getBlobIdent().path != null)pathLink.add(new Label("label", blobIdent.path.substring(context.getBlobIdent().path.length()+1)));- else if (blobIdent.path.equals(BuildSpec.BLOB_PATH))+ else if (blobIdent.path.equals(BuildSpec.BLOB_PATH) || blobIdent.path.equals(".onedev-buildspec"))pathLink.add(new Label("label", "<b>" + HtmlEscape.escapeHtml5(blobIdent.path) + "</b>").setEscapeModelStrings(false));elsepathLink.add(new Label("label", blobIdent.path));diff --git a/server-core/src/main/java/io/onedev/server/web/page/test/TestPage.java b/server-core/src/main/java/io/onedev/server/web/page/test/TestPage.javaindex def47f7a0a..40cc1a127a 100644--- a/server-core/src/main/java/io/onedev/server/web/page/test/TestPage.java+++ b/server-core/src/main/java/io/onedev/server/web/page/test/TestPage.java@@ -33,6 +33,5 @@ public class TestPage extends BasePage {super.renderHead(response);response.render(JavaScriptHeaderItem.forReference(new TestResourceReference()));response.render(OnDomReadyHeaderItem.forScript("onedev.server.test.onDomReady();"));- }-+ }}diff --git a/server-core/src/main/java/org/yaml/snakeyaml/constructor/BaseConstructor.java b/server-core/src/main/java/org/yaml/snakeyaml/constructor/BaseConstructor.javanew file mode 100644index 0000000000..8e00a0e33f--- /dev/null+++ b/server-core/src/main/java/org/yaml/snakeyaml/constructor/BaseConstructor.java@@ -0,0 +1,595 @@+/**+ * Copyright (c) 2008, http://www.snakeyaml.org+ *+ * Licensed under the Apache License, Version 2.0 (the "License");+ * you may not use this file except in compliance with the License.+ * You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */+package org.yaml.snakeyaml.constructor;++import java.lang.reflect.Array;+import java.lang.reflect.Method;+import java.lang.reflect.Modifier;+import java.util.ArrayList;+import java.util.Collection;+import java.util.EnumMap;+import java.util.HashMap;+import java.util.HashSet;+import java.util.LinkedHashMap;+import java.util.LinkedHashSet;+import java.util.List;+import java.util.Map;+import java.util.Set;+import java.util.SortedMap;+import java.util.SortedSet;+import java.util.TreeMap;+import java.util.TreeSet;++import org.yaml.snakeyaml.TypeDescription;+import org.yaml.snakeyaml.composer.Composer;+import org.yaml.snakeyaml.composer.ComposerException;+import org.yaml.snakeyaml.error.YAMLException;+import org.yaml.snakeyaml.introspector.PropertyUtils;+import org.yaml.snakeyaml.nodes.CollectionNode;+import org.yaml.snakeyaml.nodes.MappingNode;+import org.yaml.snakeyaml.nodes.Node;+import org.yaml.snakeyaml.nodes.NodeId;+import org.yaml.snakeyaml.nodes.NodeTuple;+import org.yaml.snakeyaml.nodes.ScalarNode;+import org.yaml.snakeyaml.nodes.SequenceNode;+import org.yaml.snakeyaml.nodes.Tag;++import io.onedev.server.util.BeanUtils;+import io.onedev.server.web.editable.annotation.Editable;++public abstract class BaseConstructor {+ /**+ * It maps the node kind to the the Construct implementation. When the+ * runtime class is known then the implicit tag is ignored.+ */+ protected final Map<NodeId, Construct> yamlClassConstructors = new EnumMap<NodeId, Construct>(+ NodeId.class);+ /**+ * It maps the (explicit or implicit) tag to the Construct implementation.+ * It is used:+ * 1) explicit tag - if present.+ * 2) implicit tag - when the runtime class of the instance is unknown (the+ * node has the Object.class)+ */+ protected final Map<Tag, Construct> yamlConstructors = new HashMap<Tag, Construct>();+ /**+ * It maps the (explicit or implicit) tag to the Construct implementation.+ * It is used when no exact match found.+ */+ protected final Map<String, Construct> yamlMultiConstructors = new HashMap<String, Construct>();++ protected Composer composer;+ final Map<Node, Object> constructedObjects;+ private final Set<Node> recursiveObjects;+ private final ArrayList<RecursiveTuple<Map<Object, Object>, RecursiveTuple<Object, Object>>> maps2fill;+ private final ArrayList<RecursiveTuple<Set<Object>, Object>> sets2fill;++ protected Tag rootTag;+ private PropertyUtils propertyUtils;+ private boolean explicitPropertyUtils;+ private boolean allowDuplicateKeys = true;++ protected final Map<Class<? extends Object>, TypeDescription> typeDefinitions;+ protected final Map<Tag, Class<? extends Object>> typeTags;++ public BaseConstructor() {+ constructedObjects = new HashMap<Node, Object>();+ recursiveObjects = new HashSet<Node>();+ maps2fill = new ArrayList<RecursiveTuple<Map<Object, Object>, RecursiveTuple<Object, Object>>>();+ sets2fill = new ArrayList<RecursiveTuple<Set<Object>, Object>>();+ typeDefinitions = new HashMap<Class<? extends Object>, TypeDescription>();+ typeTags = new HashMap<Tag, Class<? extends Object>>();++ rootTag = null;+ explicitPropertyUtils = false;++ typeDefinitions.put(SortedMap.class, new TypeDescription(SortedMap.class, Tag.OMAP,+ TreeMap.class));+ typeDefinitions.put(SortedSet.class, new TypeDescription(SortedSet.class, Tag.SET,+ TreeSet.class));+ }++ public void setComposer(Composer composer) {+ this.composer = composer;+ }++ /**+ * Check if more documents available+ *+ * @return true when there are more YAML documents in the stream+ */+ public boolean checkData() {+ // If there are more documents available?+ return composer.checkNode();+ }++ /**+ * Construct and return the next document+ *+ * @return constructed instance+ */+ public Object getData() {+ // Construct and return the next document.+ composer.checkNode();+ Node node = composer.getNode();+ if (rootTag != null) {+ node.setTag(rootTag);+ }+ return constructDocument(node);+ }++ /**+ * Ensure that the stream contains a single document and construct it+ *+ * @param type the class of the instance being created+ * @return constructed instance+ * @throws ComposerException in case there are more documents in the stream+ */+ public Object getSingleData(Class<?> type) {+ // Ensure that the stream contains a single document and construct it+ Node node = composer.getSingleNode();+ if (node != null && !Tag.NULL.equals(node.getTag())) {+ if (Object.class != type) {+ node.setTag(new Tag(type));+ } else if (rootTag != null) {+ node.setTag(rootTag);+ }+ return constructDocument(node);+ }+ return null;+ }++ /**+ * Construct complete YAML document. Call the second step in case of+ * recursive structures. At the end cleans all the state.+ *+ * @param node root Node+ * @return Java instance+ */+ protected final Object constructDocument(Node node) {+ Object data = constructObject(node);+ fillRecursive();+ constructedObjects.clear();+ recursiveObjects.clear();+ return data;+ }++ private void fillRecursive() {+ if (!maps2fill.isEmpty()) {+ for (RecursiveTuple<Map<Object, Object>, RecursiveTuple<Object, Object>> entry : maps2fill) {+ RecursiveTuple<Object, Object> key_value = entry._2();+ entry._1().put(key_value._1(), key_value._2());+ }+ maps2fill.clear();+ }+ if (!sets2fill.isEmpty()) {+ for (RecursiveTuple<Set<Object>, Object> value : sets2fill) {+ value._1().add(value._2());+ }+ sets2fill.clear();+ }+ }++ /**+ * Construct object from the specified Node. Return existing instance if the+ * node is already constructed.+ *+ * @param node Node to be constructed+ * @return Java instance+ */+ protected Object constructObject(Node node) {+ if (constructedObjects.containsKey(node)) {+ return constructedObjects.get(node);+ }+ return constructObjectNoCheck(node);+ }++ protected Object constructObjectNoCheck(Node node) {+ if (recursiveObjects.contains(node)) {+ throw new ConstructorException(null, null, "found unconstructable recursive node",+ node.getStartMark());+ }+ recursiveObjects.add(node);+ Construct constructor = getConstructor(node);+ Object data = (constructedObjects.containsKey(node)) ? constructedObjects.get(node)+ : constructor.construct(node);++ finalizeConstruction(node, data);+ constructedObjects.put(node, data);+ recursiveObjects.remove(node);+ if (node.isTwoStepsConstruction()) {+ constructor.construct2ndStep(node, data);+ }+ return data;+ }++ /**+ * Get the constructor to construct the Node. For implicit tags if the+ * runtime class is known a dedicated Construct implementation is used.+ * Otherwise the constructor is chosen by the tag.+ *+ * @param node {@link Node} to construct an instance from+ * @return {@link Construct} implementation for the specified node+ */+ protected Construct getConstructor(Node node) {+ if (node.useClassConstructor()) {+ return yamlClassConstructors.get(node.getNodeId());+ } else {+ Construct constructor = yamlConstructors.get(node.getTag());+ if (constructor == null) {+ for (String prefix : yamlMultiConstructors.keySet()) {+ if (node.getTag().startsWith(prefix)) {+ return yamlMultiConstructors.get(prefix);+ }+ }+ return yamlConstructors.get(null);+ }+ return constructor;+ }+ }++ protected String constructScalar(ScalarNode node) {+ return node.getValue();+ }++ // >>>> DEFAULTS >>>>+ protected List<Object> createDefaultList(int initSize) {+ return new ArrayList<Object>(initSize);+ }++ protected Set<Object> createDefaultSet(int initSize) {+ return new LinkedHashSet<Object>(initSize);+ }++ protected Map<Object, Object> createDefaultMap(int initSize) {+ // respect order from YAML document+ return new LinkedHashMap<Object, Object>(initSize);+ }++ protected Object createArray(Class<?> type, int size) {+ return Array.newInstance(type.getComponentType(), size);+ }++ // <<<< DEFAULTS <<<<++ protected Object finalizeConstruction(Node node, Object data) {+ final Class<? extends Object> type = node.getType();+ if (typeDefinitions.containsKey(type)) {+ return typeDefinitions.get(type).finalizeConstruction(data);+ }+ return data;+ }++ // >>>> NEW instance+ protected Object newInstance(Node node) {+ try {+ return newInstance(Object.class, node);+ } catch (InstantiationException e) {+ throw new YAMLException(e);+ }+ }++ final protected Object newInstance(Class<?> ancestor, Node node) throws InstantiationException {+ return newInstance(ancestor, node, true);+ }++ protected Object newInstance(Class<?> ancestor, Node node, boolean tryDefault)+ throws InstantiationException {+ final Class<? extends Object> type = node.getType();+ if (typeDefinitions.containsKey(type)) {+ TypeDescription td = typeDefinitions.get(type);+ final Object instance = td.newInstance(node);+ if (instance != null) {+ return instance;+ }+ }+ if (tryDefault) {+ /*+ * Removed <code> have InstantiationException in case of abstract+ * type+ */+ if (ancestor.isAssignableFrom(type) && !Modifier.isAbstract(type.getModifiers())) {+ try {+ java.lang.reflect.Constructor<?> c = type.getDeclaredConstructor();+ c.setAccessible(true);+ Object instance = c.newInstance();+ if (type.getAnnotation(Editable.class) != null) {+ for (Method getter: BeanUtils.findGetters(type)) {+ if (getter.getAnnotation(Editable.class) != null) {+ Method setter = BeanUtils.findSetter(getter);+ if (setter != null) {+ if (Collection.class.isAssignableFrom(getter.getReturnType()))+ setter.invoke(instance, new Object[] {new ArrayList<>()});+ else if (Map.class.isAssignableFrom(getter.getReturnType()))+ setter.invoke(instance, new Object[] {new LinkedHashMap<>()});+ else if (Object.class.isAssignableFrom(getter.getReturnType()))+ setter.invoke(instance, new Object[] {null});+ }+ }+ }+ }+ return instance;+ } catch (NoSuchMethodException e) {+ throw new InstantiationException("NoSuchMethodException:"+ + e.getLocalizedMessage());+ } catch (Exception e) {+ throw new YAMLException(e);+ }+ }+ }+ throw new InstantiationException();+ }++ @SuppressWarnings("unchecked")+ protected Set<Object> newSet(CollectionNode<?> node) {+ try {+ return (Set<Object>) newInstance(Set.class, node);+ } catch (InstantiationException e) {+ return createDefaultSet(node.getValue().size());+ }+ }++ @SuppressWarnings("unchecked")+ protected List<Object> newList(SequenceNode node) {+ try {+ return (List<Object>) newInstance(List.class, node);+ } catch (InstantiationException e) {+ return createDefaultList(node.getValue().size());+ }+ }++ @SuppressWarnings("unchecked")+ protected Map<Object, Object> newMap(MappingNode node) {+ try {+ return (Map<Object, Object>) newInstance(Map.class, node);+ } catch (InstantiationException e) {+ return createDefaultMap(node.getValue().size());+ }+ }++ // <<<< NEW instance++ // >>>> Construct => NEW, 2ndStep(filling)+ protected List<? extends Object> constructSequence(SequenceNode node) {+ List<Object> result = newList(node);+ constructSequenceStep2(node, result);+ return result;+ }++ protected Set<? extends Object> constructSet(SequenceNode node) {+ Set<Object> result = newSet(node);+ constructSequenceStep2(node, result);+ return result;+ }++ protected Object constructArray(SequenceNode node) {+ return constructArrayStep2(node, createArray(node.getType(), node.getValue().size()));+ }++ protected void constructSequenceStep2(SequenceNode node, Collection<Object> collection) {+ for (Node child : node.getValue()) {+ collection.add(constructObject(child));+ }+ }++ protected Object constructArrayStep2(SequenceNode node, Object array) {+ final Class<?> componentType = node.getType().getComponentType();++ int index = 0;+ for (Node child : node.getValue()) {+ // Handle multi-dimensional arrays...+ if (child.getType() == Object.class) {+ child.setType(componentType);+ }++ final Object value = constructObject(child);++ if (componentType.isPrimitive()) {+ // Null values are disallowed for primitives+ if (value == null) {+ throw new NullPointerException(+ "Unable to construct element value for " + child);+ }++ // Primitive arrays require quite a lot of work.+ if (byte.class.equals(componentType)) {+ Array.setByte(array, index, ((Number) value).byteValue());++ } else if (short.class.equals(componentType)) {+ Array.setShort(array, index, ((Number) value).shortValue());++ } else if (int.class.equals(componentType)) {+ Array.setInt(array, index, ((Number) value).intValue());++ } else if (long.class.equals(componentType)) {+ Array.setLong(array, index, ((Number) value).longValue());++ } else if (float.class.equals(componentType)) {+ Array.setFloat(array, index, ((Number) value).floatValue());++ } else if (double.class.equals(componentType)) {+ Array.setDouble(array, index, ((Number) value).doubleValue());++ } else if (char.class.equals(componentType)) {+ Array.setChar(array, index, ((Character) value).charValue());++ } else if (boolean.class.equals(componentType)) {+ Array.setBoolean(array, index, ((Boolean) value).booleanValue());++ } else {+ throw new YAMLException("unexpected primitive type");+ }++ } else {+ // Non-primitive arrays can simply be assigned:+ Array.set(array, index, value);+ }++ ++index;+ }+ return array;+ }++ protected Set<Object> constructSet(MappingNode node) {+ final Set<Object> set = newSet(node);+ constructSet2ndStep(node, set);+ return set;+ }++ protected Map<Object, Object> constructMapping(MappingNode node) {+ final Map<Object, Object> mapping = newMap(node);+ constructMapping2ndStep(node, mapping);+ return mapping;+ }++ protected void constructMapping2ndStep(MappingNode node, Map<Object, Object> mapping) {+ List<NodeTuple> nodeValue = node.getValue();+ for (NodeTuple tuple : nodeValue) {+ Node keyNode = tuple.getKeyNode();+ Node valueNode = tuple.getValueNode();+ Object key = constructObject(keyNode);+ if (key != null) {+ try {+ key.hashCode();// check circular dependencies+ } catch (Exception e) {+ throw new ConstructorException("while constructing a mapping",+ node.getStartMark(), "found unacceptable key " + key,+ tuple.getKeyNode().getStartMark(), e);+ }+ }+ Object value = constructObject(valueNode);+ if (keyNode.isTwoStepsConstruction()) {+ /*+ * if keyObject is created it 2 steps we should postpone putting+ * it in map because it may have different hash after+ * initialization compared to clean just created one. And map of+ * course does not observe key hashCode changes.+ */+ maps2fill.add(0,+ new RecursiveTuple<Map<Object, Object>, RecursiveTuple<Object, Object>>(+ mapping, new RecursiveTuple<Object, Object>(key, value)));+ } else {+ mapping.put(key, value);+ }+ }+ }++ protected void constructSet2ndStep(MappingNode node, Set<Object> set) {+ List<NodeTuple> nodeValue = node.getValue();+ for (NodeTuple tuple : nodeValue) {+ Node keyNode = tuple.getKeyNode();+ Object key = constructObject(keyNode);+ if (key != null) {+ try {+ key.hashCode();// check circular dependencies+ } catch (Exception e) {+ throw new ConstructorException("while constructing a Set", node.getStartMark(),+ "found unacceptable key " + key, tuple.getKeyNode().getStartMark(), e);+ }+ }+ if (keyNode.isTwoStepsConstruction()) {+ /*+ * if keyObject is created it 2 steps we should postpone putting+ * it into the set because it may have different hash after+ * initialization compared to clean just created one. And set of+ * course does not observe value hashCode changes.+ */+ sets2fill.add(0, new RecursiveTuple<Set<Object>, Object>(set, key));+ } else {+ set.add(key);+ }+ }+ }++ // <<<< Costruct => NEW, 2ndStep(filling)++ // TODO protected List<Object[]> constructPairs(MappingNode node) {+ // List<Object[]> pairs = new LinkedList<Object[]>();+ // List<Node[]> nodeValue = (List<Node[]>) node.getValue();+ // for (Iterator<Node[]> iter = nodeValue.iterator(); iter.hasNext();) {+ // Node[] tuple = iter.next();+ // Object key = constructObject(Object.class, tuple[0]);+ // Object value = constructObject(Object.class, tuple[1]);+ // pairs.add(new Object[] { key, value });+ // }+ // return pairs;+ // }++ public void setPropertyUtils(PropertyUtils propertyUtils) {+ this.propertyUtils = propertyUtils;+ explicitPropertyUtils = true;+ Collection<TypeDescription> tds = typeDefinitions.values();+ for (TypeDescription typeDescription : tds) {+ typeDescription.setPropertyUtils(propertyUtils);+ }+ }++ public final PropertyUtils getPropertyUtils() {+ if (propertyUtils == null) {+ propertyUtils = new PropertyUtils();+ }+ return propertyUtils;+ }++ /**+ * Make YAML aware how to parse a custom Class. If there is no root Class+ * assigned in constructor then the 'root' property of this definition is+ * respected.+ *+ * @param definition to be added to the Constructor+ * @return the previous value associated with <tt>definition</tt>, or+ * <tt>null</tt> if there was no mapping for <tt>definition</tt>.+ */+ public TypeDescription addTypeDescription(TypeDescription definition) {+ if (definition == null) {+ throw new NullPointerException("TypeDescription is required.");+ }+ Tag tag = definition.getTag();+ typeTags.put(tag, definition.getType());+ definition.setPropertyUtils(getPropertyUtils());+ return typeDefinitions.put(definition.getType(), definition);+ }++ private static class RecursiveTuple<T, K> {+ private final T _1;+ private final K _2;++ public RecursiveTuple(T _1, K _2) {+ this._1 = _1;+ this._2 = _2;+ }++ public K _2() {+ return _2;+ }++ public T _1() {+ return _1;+ }+ }++ public final boolean isExplicitPropertyUtils() {+ return explicitPropertyUtils;+ }++ public boolean isAllowDuplicateKeys() {+ return allowDuplicateKeys;+ }++ public void setAllowDuplicateKeys(boolean allowDuplicateKeys) {+ this.allowDuplicateKeys = allowDuplicateKeys;+ }+}diff --git a/server-core/src/main/java/org/yaml/snakeyaml/nodes/ScalarNode.java b/server-core/src/main/java/org/yaml/snakeyaml/nodes/ScalarNode.javaindex f38faa695b..2dc1de1318 100644--- a/server-core/src/main/java/org/yaml/snakeyaml/nodes/ScalarNode.java+++ b/server-core/src/main/java/org/yaml/snakeyaml/nodes/ScalarNode.java@@ -16,6 +16,7 @@package org.yaml.snakeyaml.nodes;import org.yaml.snakeyaml.DumperOptions;+import org.yaml.snakeyaml.DumperOptions.ScalarStyle;import org.yaml.snakeyaml.error.Mark;/**@@ -28,6 +29,10 @@ public class ScalarNode extends Node {private DumperOptions.ScalarStyle style;private String value;+ public ScalarNode(Tag tag, String value) {+ this(tag, value, null, null, ScalarStyle.PLAIN);+ }+public ScalarNode(Tag tag, String value, Mark startMark, Mark endMark, DumperOptions.ScalarStyle style) {this(tag, true, value, startMark, endMark, style);}diff --git a/server-core/src/main/java/org/yaml/snakeyaml/representer/Representer.java b/server-core/src/main/java/org/yaml/snakeyaml/representer/Representer.javanew file mode 100644index 0000000000..42eb415642--- /dev/null+++ b/server-core/src/main/java/org/yaml/snakeyaml/representer/Representer.java@@ -0,0 +1,274 @@+/**+ * Copyright (c) 2008, http://www.snakeyaml.org+ *+ * Licensed under the Apache License, Version 2.0 (the "License");+ * you may not use this file except in compliance with the License.+ * You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */+package org.yaml.snakeyaml.representer;++import java.util.ArrayList;+import java.util.Arrays;+import java.util.Collection;+import java.util.Collections;+import java.util.HashMap;+import java.util.Iterator;+import java.util.List;+import java.util.Map;+import java.util.Set;++import org.yaml.snakeyaml.DumperOptions;+import org.yaml.snakeyaml.DumperOptions.FlowStyle;+import org.yaml.snakeyaml.TypeDescription;+import org.yaml.snakeyaml.introspector.Property;+import org.yaml.snakeyaml.introspector.PropertyUtils;+import org.yaml.snakeyaml.nodes.MappingNode;+import org.yaml.snakeyaml.nodes.Node;+import org.yaml.snakeyaml.nodes.NodeId;+import org.yaml.snakeyaml.nodes.NodeTuple;+import org.yaml.snakeyaml.nodes.ScalarNode;+import org.yaml.snakeyaml.nodes.SequenceNode;+import org.yaml.snakeyaml.nodes.Tag;++/**+ * Represent JavaBeans+ */+public class Representer extends SafeRepresenter {++ protected Map<Class<? extends Object>, TypeDescription> typeDefinitions = Collections+ .emptyMap();++ public Representer() {+ this.representers.put(null, new RepresentJavaBean());+ }++ public TypeDescription addTypeDescription(TypeDescription td) {+ if (Collections.EMPTY_MAP == typeDefinitions) {+ typeDefinitions = new HashMap<Class<? extends Object>, TypeDescription>();+ }+ if (td.getTag() != null) {+ addClassTag(td.getType(), td.getTag());+ }+ td.setPropertyUtils(getPropertyUtils());+ return typeDefinitions.put(td.getType(), td);+ }++ @Override+ public void setPropertyUtils(PropertyUtils propertyUtils) {+ super.setPropertyUtils(propertyUtils);+ Collection<TypeDescription> tds = typeDefinitions.values();+ for (TypeDescription typeDescription : tds) {+ typeDescription.setPropertyUtils(propertyUtils);+ }+ }++ protected class RepresentJavaBean implements Represent {+ public Node representData(Object data) {+ return representJavaBean(getProperties(data.getClass()), data);+ }+ }++ /**+ * Tag logic:+ * - explicit root tag is set in serializer+ * - if there is a predefined class tag it is used+ * - a global tag with class name is always used as tag. The JavaBean parent+ * of the specified JavaBean may set another tag (tag:yaml.org,2002:map)+ * when the property class is the same as runtime class+ *+ * @param properties+ * JavaBean getters+ * @param javaBean+ * instance for Node+ * @return Node to get serialized+ */+ protected MappingNode representJavaBean(Set<Property> properties, Object javaBean) {+ List<NodeTuple> value = new ArrayList<NodeTuple>(properties.size());+ Tag tag;+ Tag customTag = classTags.get(javaBean.getClass());+ tag = customTag != null ? customTag : new Tag("!" + javaBean.getClass().getSimpleName());+ // flow style will be chosen by BaseRepresenter+ MappingNode node = new MappingNode(tag, value, FlowStyle.AUTO);+ representedObjects.put(javaBean, node);+ DumperOptions.FlowStyle bestStyle = FlowStyle.FLOW;+ for (Property property : properties) {+ Object memberValue = property.get(javaBean);+ Tag customPropertyTag = memberValue == null ? null+ : classTags.get(memberValue.getClass());+ NodeTuple tuple = representJavaBeanProperty(javaBean, property, memberValue,+ customPropertyTag);+ if (tuple == null) {+ continue;+ }+ if (!((ScalarNode) tuple.getKeyNode()).isPlain()) {+ bestStyle = FlowStyle.BLOCK;+ }+ Node nodeValue = tuple.getValueNode();+ if (!(nodeValue instanceof ScalarNode && ((ScalarNode) nodeValue).isPlain())) {+ bestStyle = FlowStyle.BLOCK;+ }+ value.add(tuple);+ }+ if (defaultFlowStyle != FlowStyle.AUTO) {+ node.setFlowStyle(defaultFlowStyle);+ } else {+ node.setFlowStyle(bestStyle);+ }+ return node;+ }++ /**+ * Represent one JavaBean property.+ *+ * @param javaBean+ * - the instance to be represented+ * @param property+ * - the property of the instance+ * @param propertyValue+ * - value to be represented+ * @param customTag+ * - user defined Tag+ * @return NodeTuple to be used in a MappingNode. Return null to skip the+ * property+ */+ protected NodeTuple representJavaBeanProperty(Object javaBean, Property property,+ Object propertyValue, Tag customTag) {+ ScalarNode nodeKey = (ScalarNode) representData(property.getName());+ // the first occurrence of the node must keep the tag+ boolean hasAlias = this.representedObjects.containsKey(propertyValue);++ Node nodeValue = representData(propertyValue);++ if (propertyValue != null && !hasAlias) {+ NodeId nodeId = nodeValue.getNodeId();+ if (customTag == null) {+ if (nodeId == NodeId.scalar) {+ if (property.getType() == propertyValue.getClass()) {+ if (propertyValue instanceof Enum<?>) {+ nodeValue.setTag(Tag.STR);+ }+ }+ } else {+ if (nodeId == NodeId.mapping) {+ if (property.getType() == propertyValue.getClass()) {+ if (!(propertyValue instanceof Map<?, ?>)) {+ if (!nodeValue.getTag().equals(Tag.SET)) {+ nodeValue.setTag(Tag.MAP);+ }+ }+ }+ }+ checkGlobalTag(property, nodeValue, propertyValue);+ }+ }+ }++ return new NodeTuple(nodeKey, nodeValue);+ }++ /**+ * Remove redundant global tag for a type safe (generic) collection if it is+ * the same as defined by the JavaBean property+ *+ * @param property+ * - JavaBean property+ * @param node+ * - representation of the property+ * @param object+ * - instance represented by the node+ */+ @SuppressWarnings("unchecked")+ protected void checkGlobalTag(Property property, Node node, Object object) {+ // Skip primitive arrays.+ if (object.getClass().isArray() && object.getClass().getComponentType().isPrimitive()) {+ return;+ }++ Class<?>[] arguments = property.getActualTypeArguments();+ if (arguments != null) {+ if (node.getNodeId() == NodeId.sequence) {+ // apply map tag where class is the same+ Class<? extends Object> t = arguments[0];+ SequenceNode snode = (SequenceNode) node;+ Iterable<Object> memberList = Collections.EMPTY_LIST;+ if (object.getClass().isArray()) {+ memberList = Arrays.asList((Object[]) object);+ } else if (object instanceof Iterable<?>) {+ // list+ memberList = (Iterable<Object>) object;+ }+ Iterator<Object> iter = memberList.iterator();+ if (iter.hasNext()) {+ for (Node childNode : snode.getValue()) {+ Object member = iter.next();+ if (member != null) {+ if (t.equals(member.getClass()))+ if (childNode.getNodeId() == NodeId.mapping) {+ childNode.setTag(Tag.MAP);+ }+ }+ }+ }+ } else if (object instanceof Set) {+ Class<?> t = arguments[0];+ MappingNode mnode = (MappingNode) node;+ Iterator<NodeTuple> iter = mnode.getValue().iterator();+ Set<?> set = (Set<?>) object;+ for (Object member : set) {+ NodeTuple tuple = iter.next();+ Node keyNode = tuple.getKeyNode();+ if (t.equals(member.getClass())) {+ if (keyNode.getNodeId() == NodeId.mapping) {+ keyNode.setTag(Tag.MAP);+ }+ }+ }+ } else if (object instanceof Map) { // NodeId.mapping ends-up here+ Class<?> keyType = arguments[0];+ Class<?> valueType = arguments[1];+ MappingNode mnode = (MappingNode) node;+ for (NodeTuple tuple : mnode.getValue()) {+ resetTag(keyType, tuple.getKeyNode());+ resetTag(valueType, tuple.getValueNode());+ }+ } else {+ // the type for collection entries cannot be+ // detected+ }+ }+ }++ private void resetTag(Class<? extends Object> type, Node node) {+ Tag tag = node.getTag();+ if (tag.matches(type)) {+ if (Enum.class.isAssignableFrom(type)) {+ node.setTag(Tag.STR);+ } else {+ node.setTag(Tag.MAP);+ }+ }+ }++ /**+ * Get JavaBean properties to be serialised. The order is respected. This+ * method may be overridden to provide custom property selection or order.+ *+ * @param type+ * - JavaBean to inspect the properties+ * @return properties to serialise+ */+ protected Set<Property> getProperties(Class<? extends Object> type) {+ if (typeDefinitions.containsKey(type)) {+ return typeDefinitions.get(type).getProperties();+ }+ return getPropertyUtils().getProperties(type);+ }+}