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:53 UTC
[4/9] brooklyn-server git commit: no longer coerce things if generic
parametrized types don't match
no longer coerce things if generic parametrized types don't match
previously we would return e.g. a List not containing T if List<T> was requested.
this was deprecated and we would warn, but now we are stricter.
Project: http://git-wip-us.apache.org/repos/asf/brooklyn-server/repo
Commit: http://git-wip-us.apache.org/repos/asf/brooklyn-server/commit/8d081d01
Tree: http://git-wip-us.apache.org/repos/asf/brooklyn-server/tree/8d081d01
Diff: http://git-wip-us.apache.org/repos/asf/brooklyn-server/diff/8d081d01
Branch: refs/heads/master
Commit: 8d081d01a3bb6e0e48ba64f13a6d4485d9d3cad8
Parents: 89c692e
Author: Alex Heneveld <al...@cloudsoftcorp.com>
Authored: Fri Aug 31 01:13:37 2018 +0100
Committer: Alex Heneveld <al...@cloudsoftcorp.com>
Committed: Fri Aug 31 01:13:37 2018 +0100
----------------------------------------------------------------------
.../org/apache/brooklyn/util/guava/Maybe.java | 2 +-
.../javalang/coerce/TypeCoercerExtensible.java | 49 ++++++++------------
2 files changed, 21 insertions(+), 30 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/brooklyn-server/blob/8d081d01/utils/common/src/main/java/org/apache/brooklyn/util/guava/Maybe.java
----------------------------------------------------------------------
diff --git a/utils/common/src/main/java/org/apache/brooklyn/util/guava/Maybe.java b/utils/common/src/main/java/org/apache/brooklyn/util/guava/Maybe.java
index 8b69cc0..5b34249 100644
--- a/utils/common/src/main/java/org/apache/brooklyn/util/guava/Maybe.java
+++ b/utils/common/src/main/java/org/apache/brooklyn/util/guava/Maybe.java
@@ -365,7 +365,7 @@ public abstract class Maybe<T> implements Serializable, Supplier<T> {
});
}
public static <T> Maybe<T> changeExceptionSupplier(Maybe<T> original, Function<AnyExceptionSupplier<?>,Supplier<? extends RuntimeException>> transform) {
- if (original.isPresent()) return original;
+ if (original==null || original.isPresent()) return original;
final Supplier<? extends RuntimeException> supplier = ((Maybe.Absent<?>)original).getExceptionSupplier();
if (!(supplier instanceof AnyExceptionSupplier)) return original;
http://git-wip-us.apache.org/repos/asf/brooklyn-server/blob/8d081d01/utils/common/src/main/java/org/apache/brooklyn/util/javalang/coerce/TypeCoercerExtensible.java
----------------------------------------------------------------------
diff --git a/utils/common/src/main/java/org/apache/brooklyn/util/javalang/coerce/TypeCoercerExtensible.java b/utils/common/src/main/java/org/apache/brooklyn/util/javalang/coerce/TypeCoercerExtensible.java
index 3465c09..a4b4846 100644
--- a/utils/common/src/main/java/org/apache/brooklyn/util/javalang/coerce/TypeCoercerExtensible.java
+++ b/utils/common/src/main/java/org/apache/brooklyn/util/javalang/coerce/TypeCoercerExtensible.java
@@ -27,6 +27,8 @@ import java.util.Map;
import java.util.Set;
import org.apache.brooklyn.util.exceptions.Exceptions;
+import org.apache.brooklyn.util.exceptions.PropagatedRuntimeException;
+import org.apache.brooklyn.util.guava.AnyExceptionSupplier;
import org.apache.brooklyn.util.guava.Maybe;
import org.apache.brooklyn.util.guava.TypeTokens;
import org.apache.brooklyn.util.javalang.Boxing;
@@ -127,34 +129,20 @@ public class TypeCoercerExtensible implements TypeCoercer {
if (targetTypeToken!=null && targetTypeToken.getType() instanceof ParameterizedType) {
if (value instanceof Iterable && Iterable.class.isAssignableFrom(targetType)) {
result = tryCoerceIterable(value, targetTypeToken, targetType);
-
- if (result != null && result.isAbsent() && targetType.isInstance(value)) {
- log.warn("Failed to coerce iterable from " + value.getClass().getName() + " to " + targetTypeToken
- + "; returning uncoerced result to preserve (deprecated) backwards compatibility",
- Maybe.getException(result));
- }
-
} else if (value.getClass().isArray() && Iterable.class.isAssignableFrom(targetType)) {
result = tryCoerceArray(value, targetTypeToken, targetType);
-
- if (result != null && result.isAbsent() && targetType.isInstance(value)) {
- log.warn("Failed to coerce array from " + value.getClass().getName() + " to " + targetTypeToken
- + "; returning uncoerced result to preserve (deprecated) backwards compatibility",
- Maybe.getException(result));
- }
-
} else if (value instanceof Map && Map.class.isAssignableFrom(targetType)) {
result = tryCoerceMap(value, targetTypeToken);
-
- if (result != null && result.isAbsent() && targetType.isInstance(value)) {
- log.warn("Failed to coerce map from " + value.getClass().getName() + " to " + targetTypeToken
- + "; returning uncoerced result to preserve (deprecated) backwards compatibility",
- Maybe.getException(result));
- }
+ }
+ if (result!=null) {
+ if (result.isPresent()) return result;
+ // Previous to v1.0.0 we'd overlook errors in generics with warnings; now we bail
+ TypeToken<T> targetTypeTokenF = targetTypeToken;
+ RuntimeException e = Maybe.getException(result);
+ return Maybe.absent(new AnyExceptionSupplier<>(ClassCoercionException.class,
+ () -> "Generic type mismatch coercing "+value.getClass().getName()+" to "+targetTypeTokenF+": "+Exceptions.collapseText(e), e));
}
}
- if (result!=null && result.isPresent()) return result;
- if (result!=null && firstError==null) firstError = result;
if (targetType.isInstance(value)) return Maybe.of( (T) value );
@@ -206,8 +194,11 @@ public class TypeCoercerExtensible implements TypeCoercer {
+ ": "+e, e);
}
if (firstError==null) {
- if (e instanceof ClassCoercionException) firstError = Maybe.absent(e);
- else firstError = Maybe.absent(new ClassCoercionException("Cannot coerce type "+value.getClass().getCanonicalName()+" to "+targetType.getCanonicalName()+" ("+value+")", e));
+ if (e instanceof ClassCoercionException) {
+ firstError = Maybe.absent(e);
+ } else {
+ firstError = Maybe.absent(new ClassCoercionException("Cannot coerce type "+value.getClass().getCanonicalName()+" to "+targetTypeToken+" ("+value+"): registered coercer failed", e));
+ }
}
continue;
}
@@ -217,7 +208,7 @@ public class TypeCoercerExtensible implements TypeCoercer {
//not found
if (firstError!=null) return firstError;
- return Maybe.absent(new ClassCoercionException("Cannot coerce type "+value.getClass().getCanonicalName()+" to "+targetType.getCanonicalName()+" ("+value+"): no adapter known"));
+ return Maybe.absent(new ClassCoercionException("Cannot coerce type "+value.getClass().getCanonicalName()+" to "+targetTypeToken+" ("+value+"): no adapter known"));
}
@SuppressWarnings("unchecked")
@@ -234,15 +225,15 @@ public class TypeCoercerExtensible implements TypeCoercer {
for (Map.Entry<?,?> entry : ((Map<?,?>) value).entrySet()) {
Maybe<?> k = tryCoerce(entry.getKey(), mapKeyType);
if (k.isAbsent()) return Maybe.absent(new ClassCoercionException(
- "Could not coerce key of entry "+i+" in "+value+" to "+targetTypeToken,
+ "Could not coerce key of entry "+i+" ("+entry.getKey()+") to "+targetTypeToken,
((Maybe.Absent<T>)k).getException()));
Maybe<?> v = tryCoerce(entry.getValue(), mapValueType);
if (v.isAbsent()) return Maybe.absent(new ClassCoercionException(
- "Could not coerce value of entry "+i+" in "+value+" to "+targetTypeToken,
+ "Could not coerce value of entry "+i+" ("+entry.getValue()+") to "+targetTypeToken,
((Maybe.Absent<T>)v).getException()));
- coerced.put(k.get(), v.get());
+ coerced.put(k.get(), v.get());
i++;
}
@@ -273,7 +264,7 @@ public class TypeCoercerExtensible implements TypeCoercer {
coerced.add(entryCoerced.get());
} else {
return Maybe.absent(new ClassCoercionException(
- "Could not coerce entry "+i+" in "+value+" to "+targetTypeToken,
+ "Could not coerce entry "+i+" ("+entry+") to "+listEntryType,
((Maybe.Absent<T>)entryCoerced).getException()));
}
i++;