You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@brooklyn.apache.org by al...@apache.org on 2018/09/04 08:23:52 UTC
[3/9] brooklyn-server git commit: coercing from string to list can
now handle objects
coercing from string to list can now handle objects
now have two methods for parsing a list as a string, depending whether it wants object or string
Project: http://git-wip-us.apache.org/repos/asf/brooklyn-server/repo
Commit: http://git-wip-us.apache.org/repos/asf/brooklyn-server/commit/89c692e4
Tree: http://git-wip-us.apache.org/repos/asf/brooklyn-server/tree/89c692e4
Diff: http://git-wip-us.apache.org/repos/asf/brooklyn-server/diff/89c692e4
Branch: refs/heads/master
Commit: 89c692e4951deb17cbca05567dea74ce2dd78860
Parents: ddc6c71
Author: Alex Heneveld <al...@cloudsoftcorp.com>
Authored: Fri Aug 31 00:24:32 2018 +0100
Committer: Alex Heneveld <al...@cloudsoftcorp.com>
Committed: Fri Aug 31 00:24:32 2018 +0100
----------------------------------------------------------------------
.../core/location/BasicLocationRegistry.java | 2 +-
.../brooklyn/core/location/PortRanges.java | 2 +-
.../location/multi/MultiLocationResolver.java | 2 +-
.../LocalhostLocationResolverTest.java | 4 +-
.../main/java/org/apache/brooklyn/cli/Main.java | 2 +-
.../coerce/CommonAdaptorTypeCoercions.java | 10 +-
.../brooklyn/util/text/StringEscapes.java | 118 ++++++++++++++++++-
.../brooklyn/util/text/StringEscapesTest.java | 80 ++++++++++++-
8 files changed, 206 insertions(+), 14 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/brooklyn-server/blob/89c692e4/core/src/main/java/org/apache/brooklyn/core/location/BasicLocationRegistry.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/brooklyn/core/location/BasicLocationRegistry.java b/core/src/main/java/org/apache/brooklyn/core/location/BasicLocationRegistry.java
index b28e560..ae77d90 100644
--- a/core/src/main/java/org/apache/brooklyn/core/location/BasicLocationRegistry.java
+++ b/core/src/main/java/org/apache/brooklyn/core/location/BasicLocationRegistry.java
@@ -513,7 +513,7 @@ public class BasicLocationRegistry implements LocationRegistry {
@Override
public List<Location> getListOfLocationsManaged(Object l) {
if (l==null) l = Collections.emptyList();
- if (l instanceof String) l = JavaStringEscapes.unwrapJsonishListIfPossible((String)l);
+ if (l instanceof String) l = JavaStringEscapes.unwrapJsonishListStringIfPossible((String)l);
if (l instanceof Iterable) return getFromIterableListOfLocationsManaged((Iterable<?>)l);
throw new IllegalArgumentException("Location list must be supplied as a collection or a string, not "+
JavaClassNames.simpleClassName(l)+"/"+l);
http://git-wip-us.apache.org/repos/asf/brooklyn-server/blob/89c692e4/core/src/main/java/org/apache/brooklyn/core/location/PortRanges.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/brooklyn/core/location/PortRanges.java b/core/src/main/java/org/apache/brooklyn/core/location/PortRanges.java
index 22a037c..b3368e0 100644
--- a/core/src/main/java/org/apache/brooklyn/core/location/PortRanges.java
+++ b/core/src/main/java/org/apache/brooklyn/core/location/PortRanges.java
@@ -196,7 +196,7 @@ public class PortRanges {
for (Object o: c) {
if (o instanceof Integer) l.add(fromInteger((Integer)o));
else if (o instanceof String)
- for (String string : JavaStringEscapes.unwrapJsonishListIfPossible((String)o))
+ for (String string : JavaStringEscapes.unwrapJsonishListStringIfPossible((String)o))
l.add(fromString(string));
else if (o instanceof Iterable) l.add(fromIterable((Iterable<?>)o));
else if (o instanceof int[]) l.add(fromIterable(Ints.asList((int[])o)));
http://git-wip-us.apache.org/repos/asf/brooklyn-server/blob/89c692e4/core/src/main/java/org/apache/brooklyn/location/multi/MultiLocationResolver.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/brooklyn/location/multi/MultiLocationResolver.java b/core/src/main/java/org/apache/brooklyn/location/multi/MultiLocationResolver.java
index 765be5f..8ab1b98 100644
--- a/core/src/main/java/org/apache/brooklyn/location/multi/MultiLocationResolver.java
+++ b/core/src/main/java/org/apache/brooklyn/location/multi/MultiLocationResolver.java
@@ -99,7 +99,7 @@ public class MultiLocationResolver implements LocationResolver {
Object targetSpecs = locationArgs.remove("targets");
if (targetSpecs instanceof String) {
- for (String targetSpec : JavaStringEscapes.unwrapJsonishListIfPossible((String)targetSpecs)) {
+ for (String targetSpec : JavaStringEscapes.unwrapJsonishListStringIfPossible((String)targetSpecs)) {
targets.add(managementContext.getLocationRegistry().getLocationSpec(targetSpec, ImmutableMap.of()).get());
}
} else if (targetSpecs instanceof Iterable) {
http://git-wip-us.apache.org/repos/asf/brooklyn-server/blob/89c692e4/core/src/test/java/org/apache/brooklyn/location/localhost/LocalhostLocationResolverTest.java
----------------------------------------------------------------------
diff --git a/core/src/test/java/org/apache/brooklyn/location/localhost/LocalhostLocationResolverTest.java b/core/src/test/java/org/apache/brooklyn/location/localhost/LocalhostLocationResolverTest.java
index 3e17883..1dc9a81 100644
--- a/core/src/test/java/org/apache/brooklyn/location/localhost/LocalhostLocationResolverTest.java
+++ b/core/src/test/java/org/apache/brooklyn/location/localhost/LocalhostLocationResolverTest.java
@@ -159,14 +159,14 @@ public class LocalhostLocationResolverTest {
@Test
public void testRegistryCommaResolution() throws NoMachinesAvailableException {
List<Location> l;
- l = getLocationResolver().getListOfLocationsManaged(JavaStringEscapes.unwrapJsonishListIfPossible("localhost,localhost,localhost"));
+ l = getLocationResolver().getListOfLocationsManaged(JavaStringEscapes.unwrapJsonishListStringIfPossible("localhost,localhost,localhost"));
assertEquals(l.size(), 3, "l="+l);
assertTrue(l.get(0) instanceof LocalhostMachineProvisioningLocation, "l="+l);
assertTrue(l.get(1) instanceof LocalhostMachineProvisioningLocation, "l="+l);
assertTrue(l.get(2) instanceof LocalhostMachineProvisioningLocation, "l="+l);
// And check works if comma in brackets
- l = getLocationResolver().getListOfLocationsManaged(JavaStringEscapes.unwrapJsonishListIfPossible(
+ l = getLocationResolver().getListOfLocationsManaged(JavaStringEscapes.unwrapJsonishListStringIfPossible(
"[ \"byon:(hosts=\\\"192.168.0.1\\\",user=bob)\", \"byon:(hosts=\\\"192.168.0.2\\\",user=bob2)\" ]"));
assertEquals(l.size(), 2, "l="+l);
assertTrue(l.get(0) instanceof FixedListMachineProvisioningLocation, "l="+l);
http://git-wip-us.apache.org/repos/asf/brooklyn-server/blob/89c692e4/server-cli/src/main/java/org/apache/brooklyn/cli/Main.java
----------------------------------------------------------------------
diff --git a/server-cli/src/main/java/org/apache/brooklyn/cli/Main.java b/server-cli/src/main/java/org/apache/brooklyn/cli/Main.java
index cc473de..4711b9f 100644
--- a/server-cli/src/main/java/org/apache/brooklyn/cli/Main.java
+++ b/server-cli/src/main/java/org/apache/brooklyn/cli/Main.java
@@ -552,7 +552,7 @@ public class Main extends AbstractMain {
.ignoreCatalogErrors(!startupFailOnCatalogErrors)
.ignoreWebErrors(startupContinueOnWebErrors)
.ignoreAppErrors(!startupFailOnManagedAppsErrors)
- .locations(Strings.isBlank(locations) ? ImmutableList.<String>of() : JavaStringEscapes.unwrapJsonishListIfPossible(locations));
+ .locations(Strings.isBlank(locations) ? ImmutableList.<String>of() : JavaStringEscapes.unwrapJsonishListStringIfPossible(locations));
launcher.restServer(!noConsole);
if (useHttps) {
http://git-wip-us.apache.org/repos/asf/brooklyn-server/blob/89c692e4/utils/common/src/main/java/org/apache/brooklyn/util/javalang/coerce/CommonAdaptorTypeCoercions.java
----------------------------------------------------------------------
diff --git a/utils/common/src/main/java/org/apache/brooklyn/util/javalang/coerce/CommonAdaptorTypeCoercions.java b/utils/common/src/main/java/org/apache/brooklyn/util/javalang/coerce/CommonAdaptorTypeCoercions.java
index 4072bc1..3c31bbc 100644
--- a/utils/common/src/main/java/org/apache/brooklyn/util/javalang/coerce/CommonAdaptorTypeCoercions.java
+++ b/utils/common/src/main/java/org/apache/brooklyn/util/javalang/coerce/CommonAdaptorTypeCoercions.java
@@ -367,14 +367,16 @@ public class CommonAdaptorTypeCoercions {
public void registerCollectionJsonAdapters() {
registerAdapter(String.class, List.class, new Function<String,List>() {
@Override
- public List<String> apply(final String input) {
- return JavaStringEscapes.unwrapJsonishListIfPossible(input);
+ public List<Object> apply(final String input) {
+ return JavaStringEscapes.tryUnwrapJsonishList(input).orNull();
}
});
registerAdapter(String.class, Set.class, new Function<String,Set>() {
@Override
- public Set<String> apply(final String input) {
- return MutableSet.copyOf(JavaStringEscapes.unwrapJsonishListIfPossible(input)).asUnmodifiable();
+ public Set<Object> apply(final String input) {
+ List<Object> l = JavaStringEscapes.tryUnwrapJsonishList(input).orNull();
+ if (l==null) return null;
+ return MutableSet.copyOf(l).asUnmodifiable();
}
});
registerAdapter(String.class, Map.class, new Function<String,Map>() {
http://git-wip-us.apache.org/repos/asf/brooklyn-server/blob/89c692e4/utils/common/src/main/java/org/apache/brooklyn/util/text/StringEscapes.java
----------------------------------------------------------------------
diff --git a/utils/common/src/main/java/org/apache/brooklyn/util/text/StringEscapes.java b/utils/common/src/main/java/org/apache/brooklyn/util/text/StringEscapes.java
index f713ff6..f3df2b2 100644
--- a/utils/common/src/main/java/org/apache/brooklyn/util/text/StringEscapes.java
+++ b/utils/common/src/main/java/org/apache/brooklyn/util/text/StringEscapes.java
@@ -23,16 +23,21 @@ import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
import javax.annotation.Nonnull;
import org.apache.brooklyn.util.collections.MutableList;
import org.apache.brooklyn.util.exceptions.Exceptions;
+import org.apache.brooklyn.util.guava.Maybe;
import org.apache.brooklyn.util.net.URLParamEncoder;
+import org.apache.brooklyn.util.yaml.Yamls;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.google.common.base.Function;
+import com.google.common.collect.Iterables;
public class StringEscapes {
@@ -315,12 +320,121 @@ public class StringEscapes {
throw new IllegalArgumentException("String '"+s+"' is not a valid Java string (unterminated string)");
}
+ /** @deprecated since 1.0.0, use {@link #unwrapJsonishListStringIfPossible(String)} (old semantics)
+ * or {@link #unwrapJsonishListStringIfPossible(String)} (improved) */
+ public static List<String> unwrapJsonishListIfPossible(String input) {
+ return unwrapJsonishListStringIfPossible(input);
+ }
+
+ /** converts a comma separated list in a single string to a list of json primitives or maps,
+ * falling back to returning the input.
+ * <p>
+ * specifically:
+ * <li> 1) if of form <code>[ X ]</code> (in brackets after trim), parse as YAML;
+ * if parse succeeds return the result, or if parse fails, return {@link Maybe#absent()}.
+ * <ll> 2) if not of form <code>[ X ]</code>, wrap in brackets and parse as YAML,
+ * and if that succeeds and is a list, return the result.
+ * <li> 3) otherwise, expect comma-separated tokens which after trimming are of the form "A" or B,
+ * where "A" is a valid Java string or C is any string not starting with '
+ * and not containing " or ,. return the list of those tokens, where A and B
+ * are their string value, and C as a primitive if it is a number or boolean or null,
+ * or else a string, including the empty string if empty.
+ * <li> 4) if such tokens are not found, return {@link Maybe#absent()}.
+ * <p>
+ * @see #unwrapOptionallyQuotedJavaStringList(String)
+ **/
+ public static Maybe<List<Object>> tryUnwrapJsonishList(String input) {
+ if (input==null) return Maybe.absent("null input cannot unwrap to a list");
+ String inputT = input.trim();
+
+ String inputYaml = null;
+ if (!inputT.startsWith("[") && !inputT.endsWith("]")) {
+ inputYaml = "[" + inputT + "]";
+ }
+ if (inputT.startsWith("[") && inputT.endsWith("]")) {
+ inputYaml = inputT;
+ }
+ if (inputYaml!=null) {
+ try {
+ Object r = Iterables.getOnlyElement( Yamls.parseAll(inputYaml) );
+ if (r instanceof List) {
+ @SuppressWarnings("unchecked")
+ List<Object> result = (List<Object>)r;
+ return Maybe.of(result);
+ }
+ } catch (Exception e) {}
+ if (inputT.startsWith("[")) {
+ // if supplied as yaml, don't allow failures
+ return Maybe.absent("Supplied format looked like YAML but could not parse as YAML");
+ }
+ }
+
+ List<Object> result = MutableList.of();
+
+ // double quote: ^ \s* " ([not quote or backslash] or [backslash any-char])* " \s* (, or $)
+ Pattern dq = Pattern.compile("^\\s*(\"([^\"\\\\]|[\\\\.])*\")\\s*(,|$)");
+ // could also support this, but we need new unescape routines
+// // single quote: ^ \s* ' ([not quote or backslash] or [backslash any-char])* ' \s* (, or $)
+// Pattern sq = Pattern.compile("^\\s*'([^\'\\\\]|[\\\\.])'*\\s*(,|$)");
+ // no quote: ^ \s* (empty, or [not ' or " or space] ([not , or "]* [not , or " or space])?) \s* (, or $)
+ Pattern nq = Pattern.compile("^\\s*(|[^,\"\\s]([^,\"]*[^,\"\\s])?)\\s*(,|$)");
+
+ int removedChars = 0;
+ while (true) {
+ Object ri;
+ Matcher m = dq.matcher(input);
+ if (m.find()) {
+ try {
+ ri = unwrapJavaString(m.group(1));
+ } catch (Exception e) {
+ Exceptions.propagateIfFatal(e);
+ return Maybe.absent("Could not match valid quote pattern" +
+ (removedChars>0 ? " at position "+removedChars : "")
+ + ": "+ Exceptions.collapseText(e));
+ }
+ } else {
+ m = nq.matcher(input);
+ if (m.find()) {
+ String w = m.group(1);
+
+ ri = w;
+ if (w.matches("[0-9]*.[0-9]+")) {
+ try {
+ ri = Double.parseDouble(w);
+ } catch (Exception e) {}
+ } else if (w.matches("[0-9]+")) {
+ try {
+ ri = Integer.parseInt(w);
+ } catch (Exception e) {}
+ } else if (Boolean.TRUE.toString().equals(w)) {
+ ri = true;
+ } else if (Boolean.FALSE.toString().equals(w)) {
+ ri = false;
+ } else if ("null".equals(w)) {
+ ri = null;
+ }
+
+ } else {
+ return Maybe.absent("Could not match valid quote pattern" +
+ (removedChars>0 ? " at position "+removedChars : ""));
+ }
+ }
+
+ result.add(ri);
+
+ input = input.substring(m.end());
+ removedChars += m.end();
+ if (!m.group(0).endsWith(",")) break;
+ }
+ return Maybe.of(result);
+ }
+
/** converts a comma separated list in a single string to a list of strings,
* doing what would be expected if given java or json style string as input,
* and falling back to returning the input.
* <p>
* this method does <b>not</b> throw exceptions on invalid input,
- * but just returns that input
+ * but just returns that input wrapped in a list
* <p>
* specifically, uses the following rules (executed once in sequence:
* <li> 1) if of form <code>[ X ]</code> (in brackets after trim),
@@ -337,7 +451,7 @@ public class StringEscapes {
* <p>
* @see #unwrapOptionallyQuotedJavaStringList(String)
**/
- public static List<String> unwrapJsonishListIfPossible(String input) {
+ public static List<String> unwrapJsonishListStringIfPossible(String input) {
try {
return unwrapOptionallyQuotedJavaStringList(input);
} catch (Exception e) {
http://git-wip-us.apache.org/repos/asf/brooklyn-server/blob/89c692e4/utils/common/src/test/java/org/apache/brooklyn/util/text/StringEscapesTest.java
----------------------------------------------------------------------
diff --git a/utils/common/src/test/java/org/apache/brooklyn/util/text/StringEscapesTest.java b/utils/common/src/test/java/org/apache/brooklyn/util/text/StringEscapesTest.java
index b864240..b23a2a7 100644
--- a/utils/common/src/test/java/org/apache/brooklyn/util/text/StringEscapesTest.java
+++ b/utils/common/src/test/java/org/apache/brooklyn/util/text/StringEscapesTest.java
@@ -18,8 +18,9 @@
*/
package org.apache.brooklyn.util.text;
+import org.apache.brooklyn.test.Asserts;
import org.apache.brooklyn.util.collections.MutableList;
-import org.apache.brooklyn.util.text.StringEscapes;
+import org.apache.brooklyn.util.collections.MutableMap;
import org.apache.brooklyn.util.text.StringEscapes.BashStringEscapes;
import org.apache.brooklyn.util.text.StringEscapes.JavaStringEscapes;
import org.testng.Assert;
@@ -83,8 +84,9 @@ public class StringEscapesTest {
Assert.assertEquals(JavaStringEscapes.wrapJavaString("Hello \"World\""), "\"Hello \\\"World\\\"\"");
}
+ @SuppressWarnings("deprecation")
@Test
- public void testJavaLists() {
+ public void testJavaListDeprecated() {
Assert.assertEquals(MutableList.of("hello", "world"),
JavaStringEscapes.unwrapQuotedJavaStringList("\"hello\", \"world\"", ","));
try {
@@ -115,4 +117,78 @@ public class StringEscapesTest {
JavaStringEscapes.unwrapJsonishListIfPossible("\"\",,x,\"\""));
}
+ @Test
+ public void testJavaListString() {
+ Assert.assertEquals(MutableList.of("hello", "world"),
+ JavaStringEscapes.unwrapQuotedJavaStringList("\"hello\", \"world\"", ","));
+ try {
+ JavaStringEscapes.unwrapQuotedJavaStringList("\"hello\", world", ",");
+ Assert.fail("Should have thrown");
+ } catch (Exception e) { /* expected */ }
+
+ Assert.assertEquals(MutableList.of("hello", "world"),
+ JavaStringEscapes.unwrapJsonishListStringIfPossible("\"hello\", \"world\""));
+ Assert.assertEquals(MutableList.of("hello"),
+ JavaStringEscapes.unwrapJsonishListStringIfPossible("hello"));
+ Assert.assertEquals(MutableList.of("hello", "world"),
+ JavaStringEscapes.unwrapJsonishListStringIfPossible("hello, world"));
+ Assert.assertEquals(MutableList.of("hello", "world"),
+ JavaStringEscapes.unwrapJsonishListStringIfPossible("\"hello\", world"));
+ Assert.assertEquals(MutableList.of("hello", "world"),
+ JavaStringEscapes.unwrapJsonishListStringIfPossible("[ \"hello\", world ]"));
+ // if can't parse e.g. because contains double quote, then returns original string as single element list
+ Assert.assertEquals(MutableList.of("hello\", \"world\""),
+ JavaStringEscapes.unwrapJsonishListStringIfPossible("hello\", \"world\""));
+ Assert.assertEquals(MutableList.of(),
+ JavaStringEscapes.unwrapJsonishListStringIfPossible(" "));
+ Assert.assertEquals(MutableList.of(""),
+ JavaStringEscapes.unwrapJsonishListStringIfPossible("\"\""));
+ Assert.assertEquals(MutableList.of("x"),
+ JavaStringEscapes.unwrapJsonishListStringIfPossible(",,x,"));
+ Assert.assertEquals(MutableList.of("","x",""),
+ JavaStringEscapes.unwrapJsonishListStringIfPossible("\"\",,x,\"\""));
+ }
+
+ @Test
+ public void testJavaListObject() {
+ Assert.assertEquals(MutableList.of("hello", "world"),
+ JavaStringEscapes.tryUnwrapJsonishList("\"hello\", \"world\"").get());
+ Assert.assertEquals(MutableList.of("hello"),
+ JavaStringEscapes.tryUnwrapJsonishList("hello").get());
+ Assert.assertEquals(MutableList.of("hello", "world"),
+ JavaStringEscapes.tryUnwrapJsonishList("hello, world").get());
+ Assert.assertEquals(MutableList.of("hello", "world"),
+ JavaStringEscapes.tryUnwrapJsonishList("\"hello\", world").get());
+ Assert.assertEquals(MutableList.of("hello", "world"),
+ JavaStringEscapes.tryUnwrapJsonishList("[ \"hello\", world ]").get());
+ Assert.assertEquals(MutableList.of(""),
+ JavaStringEscapes.tryUnwrapJsonishList(" ").get());
+ Assert.assertEquals(MutableList.of(""),
+ JavaStringEscapes.tryUnwrapJsonishList("\"\"").get());
+ Assert.assertEquals(MutableList.of("","","x",""),
+ JavaStringEscapes.tryUnwrapJsonishList(",,x,").get());
+ Assert.assertEquals(MutableList.of("","","x",""),
+ JavaStringEscapes.tryUnwrapJsonishList("\"\",,x,\"\"").get());
+
+ Assert.assertEquals(MutableList.<Object>of(1, 2, "buckle my shoe", true, "true", null, "null", ","),
+ JavaStringEscapes.tryUnwrapJsonishList("1, 2, buckle my shoe, true, \"true\", null, \"null\", \",\"").get());
+
+ try {
+ JavaStringEscapes.tryUnwrapJsonishList("\"hello").get();
+ Asserts.shouldHaveFailedPreviously();
+ } catch (Exception e) { Asserts.expectedFailureDoesNotContain(e, "position"); }
+ try {
+ JavaStringEscapes.tryUnwrapJsonishList(", \"hello").get();
+ Asserts.shouldHaveFailedPreviously();
+ } catch (Exception e) {
+ Asserts.expectedFailureContains(e, "position 1");
+ }
+
+ Assert.assertEquals(MutableList.of(MutableMap.of("a", "b"), "world"),
+ JavaStringEscapes.tryUnwrapJsonishList("[ { a: b }, world ]").get());
+
+ Assert.assertEquals(MutableList.of(MutableMap.of("a", MutableList.<Object>of("b", 2)), "world"),
+ JavaStringEscapes.tryUnwrapJsonishList("{ a: [ b, 2 ] }, world").get());
+ }
+
}