You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@brooklyn.apache.org by an...@apache.org on 2014/09/17 15:28:18 UTC
[2/6] git commit: change JSON serialization used by REST so that it
looks at fields, ignoring getters, because getters can cause infinite loops,
and fix a couple other places where JSON serialization was dodgy (streams,
apidoc)
change JSON serialization used by REST so that it looks at fields, ignoring getters, because getters can cause infinite loops,
and fix a couple other places where JSON serialization was dodgy (streams, apidoc)
Project: http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/commit/f6f9549f
Tree: http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/tree/f6f9549f
Diff: http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/diff/f6f9549f
Branch: refs/heads/master
Commit: f6f9549f9028538dadce534139268afdbf98b4a4
Parents: 761968e
Author: Alex Heneveld <al...@cloudsoftcorp.com>
Authored: Sat Sep 13 01:32:07 2014 +0100
Committer: Alex Heneveld <al...@cloudsoftcorp.com>
Committed: Sat Sep 13 02:50:53 2014 +0100
----------------------------------------------------------------------
.../brooklyn/entity/basic/BrooklynTaskTags.java | 13 +-
.../rest/util/json/BidiSerialization.java | 21 +++
.../util/json/BrooklynJacksonJsonProvider.java | 13 +-
.../json/ConfigurableSerializerProvider.java | 5 +
.../ErrorAndToStringUnknownTypeSerializer.java | 65 +++++---
...StrictPreferringFieldsVisibilityChecker.java | 107 ++++++++++++++
.../rest/resources/ApiDocResourceTest.java | 18 +++
.../json/BrooklynJacksonSerializerTest.java | 148 +++++++++++++++----
.../brooklyn/util/javalang/Reflections.java | 6 +
.../main/java/brooklyn/util/text/Strings.java | 19 ++-
.../java/brooklyn/util/text/StringsTest.java | 14 ++
.../brooklyn/rest/apidoc/ApidocEndpoint.java | 4 +
.../java/brooklyn/rest/apidoc/ApidocRoot.java | 5 +
13 files changed, 383 insertions(+), 55 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/f6f9549f/core/src/main/java/brooklyn/entity/basic/BrooklynTaskTags.java
----------------------------------------------------------------------
diff --git a/core/src/main/java/brooklyn/entity/basic/BrooklynTaskTags.java b/core/src/main/java/brooklyn/entity/basic/BrooklynTaskTags.java
index 6eee05a..b1197f2 100644
--- a/core/src/main/java/brooklyn/entity/basic/BrooklynTaskTags.java
+++ b/core/src/main/java/brooklyn/entity/basic/BrooklynTaskTags.java
@@ -24,6 +24,7 @@ import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Set;
+import org.codehaus.jackson.annotate.JsonProperty;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -34,8 +35,8 @@ import brooklyn.management.Task;
import brooklyn.util.stream.Streams;
import brooklyn.util.task.TaskTags;
import brooklyn.util.task.Tasks;
-import brooklyn.util.text.Strings;
import brooklyn.util.text.StringEscapes.BashStringEscapes;
+import brooklyn.util.text.Strings;
import com.google.common.base.Objects;
import com.google.common.base.Preconditions;
@@ -162,6 +163,16 @@ public class BrooklynTaskTags extends TaskTags {
this.streamContents = Strings.toStringSupplier(stream);
this.streamSize = Streams.sizeSupplier(stream);
}
+ // fix for https://github.com/FasterXML/jackson-databind/issues/543 (which also applies to codehaus jackson)
+ @JsonProperty
+ public Integer getStreamSize() {
+ return streamSize.get();
+ }
+ // there is a stream api so don't return everything unless explicitly requested!
+ @JsonProperty("streamContents")
+ public String getStreamContentsAbbreviated() {
+ return Strings.maxlenWithEllipsis(streamContents.get(), 80);
+ }
@Override
public String toString() {
return "Stream["+streamType+"/"+Strings.makeSizeString(streamSize.get())+"]";
http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/f6f9549f/usage/rest-server/src/main/java/brooklyn/rest/util/json/BidiSerialization.java
----------------------------------------------------------------------
diff --git a/usage/rest-server/src/main/java/brooklyn/rest/util/json/BidiSerialization.java b/usage/rest-server/src/main/java/brooklyn/rest/util/json/BidiSerialization.java
index c287367..262d202 100644
--- a/usage/rest-server/src/main/java/brooklyn/rest/util/json/BidiSerialization.java
+++ b/usage/rest-server/src/main/java/brooklyn/rest/util/json/BidiSerialization.java
@@ -38,6 +38,27 @@ import brooklyn.management.ManagementContext;
public class BidiSerialization {
+ protected final static ThreadLocal<Boolean> STRICT_SERIALIZATION = new ThreadLocal<Boolean>();
+
+ /** sets strict serialization on, or off (the default), for the current thread;
+ * recommended to be used in a <code>try { ... } finally { ... }</code> block
+ * with {@link #clearStrictSerialization()} at the end.
+ * <p>
+ * with strict serialization, classes must have public fields or annotated fields, else they will not be serialized
+ */
+ public static void setStrictSerialization(Boolean value) {
+ STRICT_SERIALIZATION.set(value);
+ }
+ public static void clearStrictSerialization() {
+ STRICT_SERIALIZATION.remove();
+ }
+ public static boolean isStrictSerialization() {
+ Boolean result = STRICT_SERIALIZATION.get();
+ if (result!=null) return result;
+ return false;
+ }
+
+
public abstract static class AbstractWithManagementContextSerialization<T> {
protected class Serializer extends JsonSerializer<T> {
http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/f6f9549f/usage/rest-server/src/main/java/brooklyn/rest/util/json/BrooklynJacksonJsonProvider.java
----------------------------------------------------------------------
diff --git a/usage/rest-server/src/main/java/brooklyn/rest/util/json/BrooklynJacksonJsonProvider.java b/usage/rest-server/src/main/java/brooklyn/rest/util/json/BrooklynJacksonJsonProvider.java
index ec0ce13..ff83689 100644
--- a/usage/rest-server/src/main/java/brooklyn/rest/util/json/BrooklynJacksonJsonProvider.java
+++ b/usage/rest-server/src/main/java/brooklyn/rest/util/json/BrooklynJacksonJsonProvider.java
@@ -25,7 +25,9 @@ import javax.ws.rs.core.MediaType;
import org.codehaus.jackson.Version;
import org.codehaus.jackson.jaxrs.JacksonJsonProvider;
import org.codehaus.jackson.map.ObjectMapper;
+import org.codehaus.jackson.map.SerializationConfig;
import org.codehaus.jackson.map.module.SimpleModule;
+import org.codehaus.jackson.map.type.TypeFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -127,10 +129,17 @@ public class BrooklynJacksonJsonProvider extends JacksonJsonProvider implements
throw new IllegalStateException("No management context available for creating ObjectMapper");
}
- ObjectMapper mapper;
+ SerializationConfig defaultConfig = new ObjectMapper().getSerializationConfig();
+ SerializationConfig sc = new SerializationConfig(
+ defaultConfig.getClassIntrospector() /* ObjectMapper.DEFAULT_INTROSPECTOR */,
+ defaultConfig.getAnnotationIntrospector() /* ObjectMapper.DEFAULT_ANNOTATION_INTROSPECTOR */,
+ new PossiblyStrictPreferringFieldsVisibilityChecker(),
+ null, null, TypeFactory.defaultInstance(), null);
+
ConfigurableSerializerProvider sp = new ConfigurableSerializerProvider();
sp.setUnknownTypeSerializer(new ErrorAndToStringUnknownTypeSerializer());
- mapper = new ObjectMapper(null, sp, null);
+
+ ObjectMapper mapper = new ObjectMapper(null, sp, null, sc, null);
SimpleModule mapperModule = new SimpleModule("Brooklyn", new Version(0, 0, 0, "ignored"));
new BidiSerialization.ManagementContextSerialization(mgmt).install(mapperModule);
http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/f6f9549f/usage/rest-server/src/main/java/brooklyn/rest/util/json/ConfigurableSerializerProvider.java
----------------------------------------------------------------------
diff --git a/usage/rest-server/src/main/java/brooklyn/rest/util/json/ConfigurableSerializerProvider.java b/usage/rest-server/src/main/java/brooklyn/rest/util/json/ConfigurableSerializerProvider.java
index feaa904..81099e6 100644
--- a/usage/rest-server/src/main/java/brooklyn/rest/util/json/ConfigurableSerializerProvider.java
+++ b/usage/rest-server/src/main/java/brooklyn/rest/util/json/ConfigurableSerializerProvider.java
@@ -36,6 +36,11 @@ final class ConfigurableSerializerProvider extends StdSerializerProvider {
public ConfigurableSerializerProvider() {}
+ public ConfigurableSerializerProvider(SerializationConfig config) {
+ // NB: not usually necessary to pass config, as object mapper gets its own config set explicitly
+ this(config, new ConfigurableSerializerProvider(), null);
+ }
+
public ConfigurableSerializerProvider(SerializationConfig config, ConfigurableSerializerProvider src, SerializerFactory jsf) {
super(config, src, jsf);
unknownTypeSerializer = src.unknownTypeSerializer;
http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/f6f9549f/usage/rest-server/src/main/java/brooklyn/rest/util/json/ErrorAndToStringUnknownTypeSerializer.java
----------------------------------------------------------------------
diff --git a/usage/rest-server/src/main/java/brooklyn/rest/util/json/ErrorAndToStringUnknownTypeSerializer.java b/usage/rest-server/src/main/java/brooklyn/rest/util/json/ErrorAndToStringUnknownTypeSerializer.java
index 79f90b5..287ebd3 100644
--- a/usage/rest-server/src/main/java/brooklyn/rest/util/json/ErrorAndToStringUnknownTypeSerializer.java
+++ b/usage/rest-server/src/main/java/brooklyn/rest/util/json/ErrorAndToStringUnknownTypeSerializer.java
@@ -20,6 +20,8 @@ package brooklyn.rest.util.json;
import java.io.IOException;
import java.io.NotSerializableException;
+import java.util.Collections;
+import java.util.Set;
import javax.annotation.Nullable;
@@ -29,42 +31,43 @@ import org.codehaus.jackson.JsonProcessingException;
import org.codehaus.jackson.JsonStreamContext;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.SerializerProvider;
+import org.codehaus.jackson.map.annotate.JsonSerialize;
import org.codehaus.jackson.map.ser.impl.UnknownSerializer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import brooklyn.util.collections.MutableSet;
+import brooklyn.util.javalang.Reflections;
+
/**
* for non-json-serializable classes (quite a lot of them!) simply provide a sensible error message and a toString.
* TODO maybe we want to attempt to serialize fields instead? (but being careful not to be self-referential!)
*/
public class ErrorAndToStringUnknownTypeSerializer extends UnknownSerializer {
-
- protected final static ThreadLocal<Boolean> STRICT_SERIALIZATION = new ThreadLocal<Boolean>();
private static final Logger log = LoggerFactory.getLogger(ErrorAndToStringUnknownTypeSerializer.class);
+ private static Set<String> WARNED_CLASSES = Collections.synchronizedSet(MutableSet.<String>of());
@Override
public void serialize(Object value, JsonGenerator jgen, SerializerProvider provider) throws IOException, JsonProcessingException {
- if (Boolean.TRUE.equals(STRICT_SERIALIZATION.get()))
+ if (BidiSerialization.isStrictSerialization())
throw new JsonMappingException("Cannot containing "+value.getClass().getName()+" and strict serialization requested");
serializeFromError(jgen.getOutputContext(), null, value, jgen, provider);
}
- public static void setStrictSerialization(Boolean value) {
- STRICT_SERIALIZATION.set(value);
- }
- public static void clearStrictSerialization() {
- STRICT_SERIALIZATION.remove();
- }
-
public void serializeFromError(JsonStreamContext ctxt, @Nullable Exception error, Object value, JsonGenerator jgen, SerializerProvider configurableSerializerProvider) throws JsonGenerationException, IOException {
if (log.isDebugEnabled())
log.debug("Recovering from json serialization error, serializing "+value+": "+error);
- if (Boolean.TRUE.equals(STRICT_SERIALIZATION.get()))
- throw new JsonMappingException("Cannot containing "+value.getClass().getName()+" and strict serialization requested");
+ if (BidiSerialization.isStrictSerialization())
+ throw new JsonMappingException("Cannot serialize "
+ + (ctxt!=null && !ctxt.inRoot() ? "object containing " : "")
+ + value.getClass().getName()+" when strict serialization requested");
+ if (WARNED_CLASSES.add(value.getClass().getCanonicalName())) {
+ log.warn("Standard serialization not possible for "+value.getClass()+" ("+value+")", error);
+ }
JsonStreamContext newCtxt = jgen.getOutputContext();
// very odd, but flush seems necessary when working with large objects; presumably a buffer which is allowed to clear itself?
@@ -77,21 +80,27 @@ public class ErrorAndToStringUnknownTypeSerializer extends UnknownSerializer {
jgen.writeStartObject();
}
- jgen.writeFieldName("error");
- jgen.writeBoolean(true);
+ if (allowEmpty(value.getClass())) {
+ // write nothing
+ } else {
- jgen.writeFieldName("errorType");
- jgen.writeString(NotSerializableException.class.getCanonicalName());
+ jgen.writeFieldName("error");
+ jgen.writeBoolean(true);
- jgen.writeFieldName("type");
- jgen.writeString(value.getClass().getCanonicalName());
+ jgen.writeFieldName("errorType");
+ jgen.writeString(NotSerializableException.class.getCanonicalName());
- jgen.writeFieldName("toString");
- jgen.writeString(value.toString());
-
- if (error!=null) {
- jgen.writeFieldName("causedByError");
- jgen.writeString(error.toString());
+ jgen.writeFieldName("type");
+ jgen.writeString(value.getClass().getCanonicalName());
+
+ jgen.writeFieldName("toString");
+ jgen.writeString(value.toString());
+
+ if (error!=null) {
+ jgen.writeFieldName("causedByError");
+ jgen.writeString(error.toString());
+ }
+
}
if (createObject) {
@@ -105,5 +114,13 @@ public class ErrorAndToStringUnknownTypeSerializer extends UnknownSerializer {
}
}
+
+ protected boolean allowEmpty(Class<? extends Object> clazz) {
+ if (clazz.getAnnotation(JsonSerialize.class)!=null && Reflections.hasNoNonObjectFields(clazz)) {
+ return true;
+ } else {
+ return false;
+ }
+ }
}
http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/f6f9549f/usage/rest-server/src/main/java/brooklyn/rest/util/json/PossiblyStrictPreferringFieldsVisibilityChecker.java
----------------------------------------------------------------------
diff --git a/usage/rest-server/src/main/java/brooklyn/rest/util/json/PossiblyStrictPreferringFieldsVisibilityChecker.java b/usage/rest-server/src/main/java/brooklyn/rest/util/json/PossiblyStrictPreferringFieldsVisibilityChecker.java
new file mode 100644
index 0000000..3f8e79d
--- /dev/null
+++ b/usage/rest-server/src/main/java/brooklyn/rest/util/json/PossiblyStrictPreferringFieldsVisibilityChecker.java
@@ -0,0 +1,107 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you 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 brooklyn.rest.util.json;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Member;
+import java.lang.reflect.Method;
+
+import org.codehaus.jackson.annotate.JsonAutoDetect;
+import org.codehaus.jackson.annotate.JsonAutoDetect.Visibility;
+import org.codehaus.jackson.annotate.JsonMethod;
+import org.codehaus.jackson.map.introspect.AnnotatedField;
+import org.codehaus.jackson.map.introspect.AnnotatedMember;
+import org.codehaus.jackson.map.introspect.AnnotatedMethod;
+import org.codehaus.jackson.map.introspect.VisibilityChecker;
+
+/** a visibility checker which disables getters, but allows private access,
+ * unless {@link BidiSerialization#isStrictSerialization()} is enabled in which case public fields or annotations must be used.
+ * <p>
+ * the reason for this change to visibility
+ * is that getters might generate a copy, resulting in infinite loops, whereas field access should never do so.
+ * (see e.g. test in {@link BrooklynJacksonSerializerTest} which uses a sensor+config object whose getTypeToken
+ * causes infinite recursion)
+ **/
+public class PossiblyStrictPreferringFieldsVisibilityChecker implements VisibilityChecker<PossiblyStrictPreferringFieldsVisibilityChecker> {
+ VisibilityChecker<?>
+ vizDefault = new VisibilityChecker.Std(Visibility.NONE, Visibility.NONE, Visibility.NONE, Visibility.ANY, Visibility.ANY),
+ vizStrict = new VisibilityChecker.Std(Visibility.NONE, Visibility.NONE, Visibility.NONE, Visibility.PUBLIC_ONLY, Visibility.PUBLIC_ONLY);
+
+ @Override public PossiblyStrictPreferringFieldsVisibilityChecker with(JsonAutoDetect ann) { throw new UnsupportedOperationException(); }
+ @Override public PossiblyStrictPreferringFieldsVisibilityChecker with(Visibility v) { throw new UnsupportedOperationException(); }
+ @Override public PossiblyStrictPreferringFieldsVisibilityChecker withVisibility(JsonMethod method, Visibility v) { throw new UnsupportedOperationException(); }
+ @Override public PossiblyStrictPreferringFieldsVisibilityChecker withGetterVisibility(Visibility v) { throw new UnsupportedOperationException(); }
+ @Override public PossiblyStrictPreferringFieldsVisibilityChecker withIsGetterVisibility(Visibility v) { throw new UnsupportedOperationException(); }
+ @Override public PossiblyStrictPreferringFieldsVisibilityChecker withSetterVisibility(Visibility v) { throw new UnsupportedOperationException(); }
+ @Override public PossiblyStrictPreferringFieldsVisibilityChecker withCreatorVisibility(Visibility v) { throw new UnsupportedOperationException(); }
+ @Override public PossiblyStrictPreferringFieldsVisibilityChecker withFieldVisibility(Visibility v) { throw new UnsupportedOperationException(); }
+
+ protected VisibilityChecker<?> viz() {
+ return BidiSerialization.isStrictSerialization() ? vizStrict : vizDefault;
+ }
+
+ @Override public boolean isGetterVisible(Method m) {
+ return viz().isGetterVisible(m);
+ }
+
+ @Override
+ public boolean isGetterVisible(AnnotatedMethod m) {
+ return isGetterVisible(m.getAnnotated());
+ }
+
+ @Override
+ public boolean isIsGetterVisible(Method m) {
+ return viz().isIsGetterVisible(m);
+ }
+
+ @Override
+ public boolean isIsGetterVisible(AnnotatedMethod m) {
+ return isIsGetterVisible(m.getAnnotated());
+ }
+
+ @Override
+ public boolean isSetterVisible(Method m) {
+ return viz().isSetterVisible(m);
+ }
+
+ @Override
+ public boolean isSetterVisible(AnnotatedMethod m) {
+ return isSetterVisible(m.getAnnotated());
+ }
+
+ @Override
+ public boolean isCreatorVisible(Member m) {
+ return viz().isCreatorVisible(m);
+ }
+
+ @Override
+ public boolean isCreatorVisible(AnnotatedMember m) {
+ return isCreatorVisible(m.getMember());
+ }
+
+ @Override
+ public boolean isFieldVisible(Field f) {
+ return viz().isFieldVisible(f);
+ }
+
+ @Override
+ public boolean isFieldVisible(AnnotatedField f) {
+ return isFieldVisible(f.getAnnotated());
+ }
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/f6f9549f/usage/rest-server/src/test/java/brooklyn/rest/resources/ApiDocResourceTest.java
----------------------------------------------------------------------
diff --git a/usage/rest-server/src/test/java/brooklyn/rest/resources/ApiDocResourceTest.java b/usage/rest-server/src/test/java/brooklyn/rest/resources/ApiDocResourceTest.java
index ff6f1b2..66d707d 100644
--- a/usage/rest-server/src/test/java/brooklyn/rest/resources/ApiDocResourceTest.java
+++ b/usage/rest-server/src/test/java/brooklyn/rest/resources/ApiDocResourceTest.java
@@ -54,12 +54,30 @@ public class ApiDocResourceTest extends BrooklynRestResourceTest {
}
@Test
+ public void testRootSerializesSensibly() throws Exception {
+ String data = client().resource("/v1/apidoc/").get(String.class);
+ log.info("apidoc gives: "+data);
+ // make sure no scala gets in
+ Assert.assertFalse(data.contains("$"));
+ Assert.assertFalse(data.contains("scala"));
+ }
+
+ @Test
public void testCountRestResources() throws Exception {
ApidocRoot response = client().resource("/v1/apidoc/").get(ApidocRoot.class);
assertEquals(response.getApis().size(), 1 + Iterables.size(BrooklynRestApi.getBrooklynRestResources()));
}
@Test
+ public void testEndpointSerializesSensibly() throws Exception {
+ String data = client().resource("/v1/apidoc/brooklyn.rest.resources.ApidocResource").get(String.class);
+ log.info("apidoc endpoint resource gives: "+data);
+ // make sure no scala gets in
+ Assert.assertFalse(data.contains("$"));
+ Assert.assertFalse(data.contains("scala"));
+ }
+
+ @Test
public void testApiDocDetails() throws Exception {
ApidocRoot response = client().resource("/v1/apidoc/brooklyn.rest.resources.ApidocResource").get(ApidocRoot.class);
assertEquals(countOperations(response), 2);
http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/f6f9549f/usage/rest-server/src/test/java/brooklyn/rest/util/json/BrooklynJacksonSerializerTest.java
----------------------------------------------------------------------
diff --git a/usage/rest-server/src/test/java/brooklyn/rest/util/json/BrooklynJacksonSerializerTest.java b/usage/rest-server/src/test/java/brooklyn/rest/util/json/BrooklynJacksonSerializerTest.java
index 9a2dea6..29dd280 100644
--- a/usage/rest-server/src/test/java/brooklyn/rest/util/json/BrooklynJacksonSerializerTest.java
+++ b/usage/rest-server/src/test/java/brooklyn/rest/util/json/BrooklynJacksonSerializerTest.java
@@ -20,12 +20,15 @@ package brooklyn.rest.util.json;
import java.io.IOException;
import java.io.NotSerializableException;
+import java.util.LinkedList;
+import java.util.List;
import java.util.Map;
import org.codehaus.jackson.JsonGenerationException;
import org.codehaus.jackson.annotate.JsonProperty;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;
+import org.codehaus.jackson.map.annotate.JsonSerialize;
import org.eclipse.jetty.server.Server;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@@ -33,6 +36,8 @@ import org.testng.Assert;
import org.testng.annotations.Test;
import brooklyn.entity.Entity;
+import brooklyn.entity.basic.Attributes;
+import brooklyn.entity.basic.BrooklynTaskTags;
import brooklyn.entity.basic.Entities;
import brooklyn.management.ManagementContext;
import brooklyn.rest.BrooklynRestApiLauncher;
@@ -40,7 +45,11 @@ import brooklyn.test.HttpTestUtils;
import brooklyn.test.entity.LocalManagementContextForTests;
import brooklyn.test.entity.TestApplication;
import brooklyn.test.entity.TestEntity;
+import brooklyn.util.collections.MutableList;
+import brooklyn.util.collections.MutableMap;
import brooklyn.util.exceptions.Exceptions;
+import brooklyn.util.stream.Streams;
+import brooklyn.util.text.Strings;
import com.google.gson.Gson;
@@ -91,51 +100,137 @@ public class BrooklynJacksonSerializerTest {
}
}
- public static class AngrySelfRefNonSerializableClass {
+ public static class SelfRefNonSerializableClass {
@JsonProperty
Object bogus = this;
}
@Test
public void testSelfReferenceFailsWhenStrict() {
- checkNonSerializableWhenStrict(new AngrySelfRefNonSerializableClass());
+ checkNonSerializableWhenStrict(new SelfRefNonSerializableClass());
}
@Test
public void testSelfReferenceGeneratesErrorMapObject() throws JsonGenerationException, JsonMappingException, IOException {
- checkSerializesWithErrorAndToString(new AngrySelfRefNonSerializableClass());
+ checkSerializesAsMapWithErrorAndToString(new SelfRefNonSerializableClass());
+ }
+ @Test
+ public void testNonSerializableInListIsShownInList() throws JsonGenerationException, JsonMappingException, IOException {
+ List<?> result = checkSerializesAs(MutableList.of(1, new SelfRefNonSerializableClass()), List.class);
+ Assert.assertEquals( result.get(0), 1 );
+ Assert.assertEquals( ((Map<?,?>)result.get(1)).get("errorType"), NotSerializableException.class.getName() );
+ }
+ @Test
+ public void testNonSerializableInMapIsShownInMap() throws JsonGenerationException, JsonMappingException, IOException {
+ Map<?,?> result = checkSerializesAs(MutableMap.of("x", new SelfRefNonSerializableClass()), Map.class);
+ Assert.assertEquals( ((Map<?,?>)result.get("x")).get("errorType"), NotSerializableException.class.getName() );
+ }
+ static class TupleWithNonSerializable {
+ String good = "bon";
+ SelfRefNonSerializableClass bad = new SelfRefNonSerializableClass();
+ }
+ @Test
+ public void testNonSerializableInObjectIsShownInMap() throws JsonGenerationException, JsonMappingException, IOException {
+ String resultS = checkSerializesAs(new TupleWithNonSerializable(), null);
+ log.info("nested non-serializable json is "+resultS);
+ Assert.assertTrue(resultS.startsWith("{\"good\":\"bon\",\"bad\":{"), "expected a nested map for the error field, not "+resultS);
+
+ Map<?,?> result = checkSerializesAs(new TupleWithNonSerializable(), Map.class);
+ Assert.assertEquals( result.get("good"), "bon" );
+ Assert.assertTrue( result.containsKey("bad"), "Should have had a key for field 'bad'" );
+ Assert.assertEquals( ((Map<?,?>)result.get("bad")).get("errorType"), NotSerializableException.class.getName() );
}
- public static class AngryEmptyNonSerializableClass {
+ public static class EmptyClass {
}
@Test
- public void testEmptyNonSerializable() throws JsonGenerationException, JsonMappingException, IOException {
- checkSerializesWithErrorAndToString(new AngryEmptyNonSerializableClass());
- // could instead to this (just return {})
-// Map<?, ?> map = checkSerializesAsMap( new AngryEmptyNonSerializableClass() );
-// Assert.assertTrue(map.isEmpty(), "Expected an empty map (ie Gson serialization); instead got: "+map);
+ public void testEmptySerializesAsEmpty() throws JsonGenerationException, JsonMappingException, IOException {
+ // deliberately, a class with no fields and no annotations serializes as an error,
+ // because the alternative, {}, is useless. however if it *is* annotated, as below, then it will serialize fine.
+ checkSerializesAsMapWithErrorAndToString(new SelfRefNonSerializableClass());
}
-
@Test
public void testEmptyNonSerializableFailsWhenStrict() {
- checkNonSerializableWhenStrict(new AngryEmptyNonSerializableClass());
+ checkNonSerializableWhenStrict(new EmptyClass());
+ }
+
+ @JsonSerialize
+ public static class EmptyClassWithSerialize {
+ }
+
+ @Test
+ public void testEmptyAnnotatedSerializesAsEmptyEvenWhenStrict() throws JsonGenerationException, JsonMappingException, IOException {
+ try {
+ BidiSerialization.setStrictSerialization(true);
+ testEmptyAnnotatedSerializesAsEmpty();
+ } finally {
+ BidiSerialization.clearStrictSerialization();
+ }
}
- protected Map<?,?> checkSerializesAsMap(Object x) {
+ @Test
+ public void testEmptyAnnotatedSerializesAsEmpty() throws JsonGenerationException, JsonMappingException, IOException {
+ Map<?, ?> map = checkSerializesAs( new EmptyClassWithSerialize(), Map.class );
+ Assert.assertTrue(map.isEmpty(), "Expected an empty map; instead got: "+map);
+
+ String result = checkSerializesAs( MutableList.of(new EmptyClassWithSerialize()), null );
+ result = result.replaceAll(" ", "").trim();
+ Assert.assertEquals(result, "[{}]");
+ }
+
+ @Test
+ public void testSensorFailsWhenStrict() {
+ checkNonSerializableWhenStrict(MutableList.of(Attributes.HTTP_PORT));
+ }
+ @Test
+ public void testSensorSensible() throws JsonGenerationException, JsonMappingException, IOException {
+ Map<?,?> result = checkSerializesAs(Attributes.HTTP_PORT, Map.class);
+ log.info("SENSOR json is: "+result);
+ Assert.assertFalse(result.toString().contains("error"), "Shouldn't have had an error, instead got: "+result);
+ }
+
+ @Test
+ public void testLinkedListSerialization() throws JsonGenerationException, JsonMappingException, IOException {
+ LinkedList<Object> ll = new LinkedList<Object>();
+ ll.add(1); ll.add("two");
+ String result = checkSerializesAs(ll, null);
+ log.info("LLIST json is: "+result);
+ Assert.assertFalse(result.toString().contains("error"), "Shouldn't have had an error, instead got: "+result);
+ Assert.assertEquals(Strings.collapseWhitespace(result, ""), "[1,\"two\"]");
+ }
+
+ @Test
+ public void testSupplierSerialization() throws JsonGenerationException, JsonMappingException, IOException {
+ String result = checkSerializesAs(Strings.toStringSupplier(Streams.byteArrayOfString("x")), null);
+ log.info("SUPPLIER json is: "+result);
+ Assert.assertFalse(result.contains("error"), "Shouldn't have had an error, instead got: "+result);
+ }
+
+ @Test
+ public void testWrappedStreamSerialization() throws JsonGenerationException, JsonMappingException, IOException {
+ String result = checkSerializesAs(BrooklynTaskTags.tagForStream("TEST", Streams.byteArrayOfString("x")), null);
+ log.info("WRAPPED STREAM json is: "+result);
+ Assert.assertFalse(result.contains("error"), "Shouldn't have had an error, instead got: "+result);
+ }
+
+ @SuppressWarnings("unchecked")
+ protected <T> T checkSerializesAs(Object x, Class<T> type) {
ManagementContext mgmt = LocalManagementContextForTests.newInstance();
try {
ObjectMapper mapper = BrooklynJacksonJsonProvider.newPrivateObjectMapper(mgmt);
String tS = mapper.writeValueAsString(x);
- log.info("angry-empty json is: "+tS);
- return mapper.readValue(tS, Map.class);
+ log.debug("serialized "+x+" as "+tS);
+ Assert.assertTrue(tS.length() < 1000, "Data too long, size "+tS.length()+" for "+x);
+ if (type==null) return (T) tS;
+ return mapper.readValue(tS, type);
} catch (Exception e) {
throw Exceptions.propagate(e);
} finally {
Entities.destroyAll(mgmt);
}
}
- protected Map<?,?> checkSerializesWithErrorAndToString(Object x) {
- Map<?,?> rt = checkSerializesAsMap(x);
+ protected Map<?,?> checkSerializesAsMapWithErrorAndToString(Object x) {
+ Map<?,?> rt = checkSerializesAs(x, Map.class);
Assert.assertEquals(rt.get("toString"), x.toString());
Assert.assertEquals(rt.get("error"), true);
return rt;
@@ -148,7 +243,7 @@ public class BrooklynJacksonSerializerTest {
try {
ObjectMapper mapper = BrooklynJacksonJsonProvider.newPrivateObjectMapper(mgmt);
if (strict)
- ErrorAndToStringUnknownTypeSerializer.setStrictSerialization(true);
+ BidiSerialization.setStrictSerialization(true);
String tS = mapper.writeValueAsString(x);
Assert.fail("Should not have serialized "+x+"; instead gave: "+tS);
@@ -159,7 +254,7 @@ public class BrooklynJacksonSerializerTest {
} finally {
if (strict)
- ErrorAndToStringUnknownTypeSerializer.clearStrictSerialization();
+ BidiSerialization.clearStrictSerialization();
Entities.destroyAll(mgmt);
}
}
@@ -204,8 +299,8 @@ public class BrooklynJacksonSerializerTest {
Assert.assertEquals(values.get("type"), Entity.class.getCanonicalName());
Assert.assertEquals(values.get("id"), app.getId());
- // and Angry gives the toString
- AngrySelfRefNonSerializableClass angry = new AngrySelfRefNonSerializableClass();
+ // and self-ref gives error + toString
+ SelfRefNonSerializableClass angry = new SelfRefNonSerializableClass();
app.setConfig(TestEntity.CONF_OBJECT, angry);
content = HttpTestUtils.getContent(entityUrl+"/config/"+TestEntity.CONF_OBJECT.getName());
log.info("CONFIG ANGRY is:\n"+content);
@@ -214,14 +309,13 @@ public class BrooklynJacksonSerializerTest {
// as does Server
app.setConfig(TestEntity.CONF_OBJECT, server);
content = HttpTestUtils.getContent(entityUrl+"/config/"+TestEntity.CONF_OBJECT.getName());
- // don't log -- it's very long (7MB? 70MB?) and wreaks havoc w eclipse console regex parsing!
- // surprising that so much of it is renderable!
-// log.info("CONFIG SERVER is:\n"+content);
- log.debug("CONFIG SERVER is:\n"+content);
- Assert.assertNotNull(content);
- new Gson().fromJson(content, Object.class);
+ // NOTE, if using the default visibility / object mapper, the getters of the object are invoked
+ // resulting in an object which is huge, 7+MB -- and it wreaks havoc w eclipse console regex parsing!
+ // (but with our custom VisibilityChecker server just gives us the nicer error!)
+ log.info("CONFIG SERVER is:\n"+content);
+ assertErrorObjectMatchingToString(content, server);
Assert.assertTrue(content.indexOf(NotSerializableException.class.getCanonicalName())>=0, "server should have contained things which are not serializable");
- Assert.assertTrue(content.length() > 500, "content should have been very long; instead was: "+content);
+ Assert.assertTrue(content.length() < 1024, "content should not have been very long; instead was: "+content.length());
} finally {
try {
http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/f6f9549f/utils/common/src/main/java/brooklyn/util/javalang/Reflections.java
----------------------------------------------------------------------
diff --git a/utils/common/src/main/java/brooklyn/util/javalang/Reflections.java b/utils/common/src/main/java/brooklyn/util/javalang/Reflections.java
index 3aaeca6..4bc5246 100644
--- a/utils/common/src/main/java/brooklyn/util/javalang/Reflections.java
+++ b/utils/common/src/main/java/brooklyn/util/javalang/Reflections.java
@@ -775,4 +775,10 @@ public class Reflections {
return false;
}
}
+
+ public static boolean hasNoNonObjectFields(Class<? extends Object> clazz) {
+ if (Object.class.equals(clazz)) return true;
+ if (clazz.getDeclaredFields().length>0) return false;
+ return hasNoNonObjectFields(clazz.getSuperclass());
+ }
}
http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/f6f9549f/utils/common/src/main/java/brooklyn/util/text/Strings.java
----------------------------------------------------------------------
diff --git a/utils/common/src/main/java/brooklyn/util/text/Strings.java b/utils/common/src/main/java/brooklyn/util/text/Strings.java
index de9d422..608e20d 100644
--- a/utils/common/src/main/java/brooklyn/util/text/Strings.java
+++ b/utils/common/src/main/java/brooklyn/util/text/Strings.java
@@ -600,8 +600,19 @@ public class Strings {
/** returns up to maxlen characters from the start of s */
public static String maxlen(String s, int maxlen) {
+ return maxlenWithEllipsis(s, maxlen, "");
+ }
+
+ /** as {@link #maxlenWithEllipsis(String, int, String) with "..." as the ellipsis */
+ public static String maxlenWithEllipsis(String s, int maxlen) {
+ return maxlenWithEllipsis(s, maxlen, "...");
+ }
+ /** as {@link #maxlenWithEllipsis(String, int) but replacing the last few chars with the given ellipsis */
+ public static String maxlenWithEllipsis(String s, int maxlen, String ellipsis) {
if (s==null) return null;
- return s.substring(0, Math.min(s.length(), maxlen));
+ if (ellipsis==null) ellipsis="";
+ if (s.length()<=maxlen) return s;
+ return s.substring(0, Math.max(maxlen-ellipsis.length(), 0))+ellipsis;
}
/** returns toString of the object if it is not null, otherwise null */
@@ -798,4 +809,10 @@ public class Strings {
return getDecimalSeparator(Locale.getDefault());
}
+ /** replaces each sequence of whitespace in the first string with the replacement in the second string */
+ public static String collapseWhitespace(String x, String whitespaceReplacement) {
+ if (x==null) return null;
+ return replaceAllRegex(x, "\\s+", whitespaceReplacement);
+ }
+
}
http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/f6f9549f/utils/common/src/test/java/brooklyn/util/text/StringsTest.java
----------------------------------------------------------------------
diff --git a/utils/common/src/test/java/brooklyn/util/text/StringsTest.java b/utils/common/src/test/java/brooklyn/util/text/StringsTest.java
index 49d29f8..9fea095 100644
--- a/utils/common/src/test/java/brooklyn/util/text/StringsTest.java
+++ b/utils/common/src/test/java/brooklyn/util/text/StringsTest.java
@@ -324,5 +324,19 @@ public class StringsTest extends FixedLocaleTest {
// skips E notation and gives extra precision when it's free
Assert.assertEquals(Strings.makeRealString(123456, 8, 2, 0), "123456");
}
+
+ @Test
+ public void testCollapseWhitespace() {
+ Assert.assertEquals(Strings.collapseWhitespace(" x\n y\n", ""), "xy");
+ Assert.assertEquals(Strings.collapseWhitespace(" x\n y\n", " "), " x y ");
+ Assert.assertEquals(Strings.collapseWhitespace(" x\n y\n", "\n").trim(), "x\ny");
+ }
+ @Test
+ public void testMaxlen() {
+ Assert.assertEquals(Strings.maxlen("hello world", 5), "hello");
+ Assert.assertEquals(Strings.maxlenWithEllipsis("hello world", 9), "hello ...");
+ Assert.assertEquals(Strings.maxlenWithEllipsis("hello world", 7, "--"), "hello--");
+ }
+
}
http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/f6f9549f/utils/rest-swagger/src/main/java/brooklyn/rest/apidoc/ApidocEndpoint.java
----------------------------------------------------------------------
diff --git a/utils/rest-swagger/src/main/java/brooklyn/rest/apidoc/ApidocEndpoint.java b/utils/rest-swagger/src/main/java/brooklyn/rest/apidoc/ApidocEndpoint.java
index 567b886..d150698 100644
--- a/utils/rest-swagger/src/main/java/brooklyn/rest/apidoc/ApidocEndpoint.java
+++ b/utils/rest-swagger/src/main/java/brooklyn/rest/apidoc/ApidocEndpoint.java
@@ -21,10 +21,14 @@ package brooklyn.rest.apidoc;
import java.util.Comparator;
import org.codehaus.jackson.annotate.JsonCreator;
+import org.codehaus.jackson.annotate.JsonIgnoreProperties;
import org.codehaus.jackson.annotate.JsonProperty;
import com.wordnik.swagger.core.DocumentationEndPoint;
+@JsonIgnoreProperties({
+ "com$wordnik$swagger$core$DocumentationEndPoint$$ops"
+})
public class ApidocEndpoint extends DocumentationEndPoint {
public static final Comparator<ApidocEndpoint> COMPARATOR = new Comparator<ApidocEndpoint>() {
http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/f6f9549f/utils/rest-swagger/src/main/java/brooklyn/rest/apidoc/ApidocRoot.java
----------------------------------------------------------------------
diff --git a/utils/rest-swagger/src/main/java/brooklyn/rest/apidoc/ApidocRoot.java b/utils/rest-swagger/src/main/java/brooklyn/rest/apidoc/ApidocRoot.java
index 7f7efae..5f4ff86 100644
--- a/utils/rest-swagger/src/main/java/brooklyn/rest/apidoc/ApidocRoot.java
+++ b/utils/rest-swagger/src/main/java/brooklyn/rest/apidoc/ApidocRoot.java
@@ -20,11 +20,16 @@ package brooklyn.rest.apidoc;
import java.util.List;
+import org.codehaus.jackson.annotate.JsonIgnoreProperties;
import org.codehaus.jackson.annotate.JsonProperty;
import org.codehaus.jackson.annotate.JsonSetter;
import com.wordnik.swagger.core.Documentation;
+@JsonIgnoreProperties({
+ "com$wordnik$swagger$core$Documentation$$apis",
+ "com$wordnik$swagger$core$Documentation$$models"
+})
public class ApidocRoot extends Documentation {
@SuppressWarnings({ "unchecked", "rawtypes" })