You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@brooklyn.apache.org by ha...@apache.org on 2015/08/18 17:03:34 UTC
[25/64] [abbrv] incubator-brooklyn git commit: BROOKLYN-162 - apply
org.apache package prefix to utils-common
http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/cf2f7a93/utils/common/src/main/java/brooklyn/util/javalang/Boxing.java
----------------------------------------------------------------------
diff --git a/utils/common/src/main/java/brooklyn/util/javalang/Boxing.java b/utils/common/src/main/java/brooklyn/util/javalang/Boxing.java
deleted file mode 100644
index 72f5138..0000000
--- a/utils/common/src/main/java/brooklyn/util/javalang/Boxing.java
+++ /dev/null
@@ -1,102 +0,0 @@
-/*
- * 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.util.javalang;
-
-import java.lang.reflect.Array;
-
-import brooklyn.util.guava.Maybe;
-
-import com.google.common.collect.ImmutableBiMap;
-
-public class Boxing {
-
- public static boolean unboxSafely(Boolean ref, boolean valueIfNull) {
- if (ref==null) return valueIfNull;
- return ref.booleanValue();
- }
-
- public static final ImmutableBiMap<Class<?>, Class<?>> PRIMITIVE_TO_BOXED =
- ImmutableBiMap.<Class<?>, Class<?>>builder()
- .put(Integer.TYPE, Integer.class)
- .put(Long.TYPE, Long.class)
- .put(Double.TYPE, Double.class)
- .put(Float.TYPE, Float.class)
- .put(Boolean.TYPE, Boolean.class)
- .put(Character.TYPE, Character.class)
- .put(Byte.TYPE, Byte.class)
- .put(Short.TYPE, Short.class)
- .put(Void.TYPE, Void.class)
- .build();
-
- /** Returns the unboxed type for the given primitive type name, if available;
- * e.g. {@link Integer#TYPE} for <code>int</code> (distinct from <code>Integer.class</code>),
- * or null if not a primitive.
- * */
- public static Maybe<Class<?>> getPrimitiveType(String typeName) {
- if (typeName!=null) {
- for (Class<?> t: PRIMITIVE_TO_BOXED.keySet()) {
- if (typeName.equals(t.getName())) return Maybe.<Class<?>>of(t);
- }
- }
- return Maybe.absent("Not a primitive: "+typeName);
- }
-
- public static Class<?> boxedType(Class<?> type) {
- if (PRIMITIVE_TO_BOXED.containsKey(type))
- return PRIMITIVE_TO_BOXED.get(type);
- return type;
- }
-
- /** sets the given element in an array to the indicated value;
- * if the type is a primitive type, the appropriate primitive method is used
- * <p>
- * this is needed because arrays do not deal with autoboxing */
- public static void setInArray(Object target, int index, Object value, Class<?> type) {
- if (PRIMITIVE_TO_BOXED.containsKey(type)) {
- if (type.equals(Integer.TYPE))
- Array.setInt(target, index, (Integer)value);
- else if (type.equals(Long.TYPE))
- Array.setLong(target, index, (Long)value);
- else if (type.equals(Double.TYPE))
- Array.setDouble(target, index, (Double)value);
- else if (type.equals(Float.TYPE))
- Array.setFloat(target, index, (Float)value);
- else if (type.equals(Boolean.TYPE))
- Array.setBoolean(target, index, (Boolean)value);
- else if (type.equals(Character.TYPE))
- Array.setChar(target, index, (Character)value);
- else if (type.equals(Byte.TYPE))
- Array.setByte(target, index, (Byte)value);
- else if (type.equals(Short.TYPE))
- Array.setShort(target, index, (Short)value);
-
- else if (type.equals(Void.TYPE))
- Array.set(target, index, (Void)value);
-
- else
- // should not happen!
- throw new IllegalStateException("Unsupported primitive: "+type);
-
- return;
- }
-
- Array.set(target, index, value);
- }
-
-}
http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/cf2f7a93/utils/common/src/main/java/brooklyn/util/javalang/Enums.java
----------------------------------------------------------------------
diff --git a/utils/common/src/main/java/brooklyn/util/javalang/Enums.java b/utils/common/src/main/java/brooklyn/util/javalang/Enums.java
deleted file mode 100644
index f79fb6e..0000000
--- a/utils/common/src/main/java/brooklyn/util/javalang/Enums.java
+++ /dev/null
@@ -1,170 +0,0 @@
-/*
- * 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.util.javalang;
-
-import java.util.Arrays;
-import java.util.Set;
-
-import brooklyn.util.collections.MutableSet;
-import brooklyn.util.exceptions.Exceptions;
-import brooklyn.util.guava.Maybe;
-import brooklyn.util.text.StringFunctions;
-import brooklyn.util.text.Strings;
-
-import com.google.common.base.CaseFormat;
-import com.google.common.base.Function;
-import com.google.common.collect.Iterables;
-
-public class Enums {
-
- /** returns a function which given an enum, returns its <code>name()</code> function
- * @deprecated since 0.7.0 use {@link #nameFunction()} to avoid inner class */
- @Deprecated
- public static Function<Enum<?>,String> enumValueNameFunction() {
- return new Function<Enum<?>,String>() {
- @Override
- public String apply(Enum<?> input) {
- return input.name();
- }
- };
- }
-
- private static final class EnumToNameFunction implements Function<Enum<?>, String> {
- @Override
- public String apply(Enum<?> input) {
- return input.name();
- }
- }
-
- /** returns a function which given an enum, returns its <code>name()</code> function */
- public static Function<Enum<?>,String> nameFunction() {
- return new EnumToNameFunction();
- }
-
- private static final class EnumFromStringFunction<T extends Enum<?>> implements Function<String,T> {
- private final Class<T> type;
- public EnumFromStringFunction(Class<T> type) { this.type = type; }
- @Override
- public T apply(String input) {
- return valueOfIgnoreCase(type, input).orNull();
- }
- }
-
- /** returns a function which given a string, produces an enum of the given type or null */
- public static <T extends Enum<?>> Function<String,T> fromStringFunction(Class<T> type) {
- return new EnumFromStringFunction<T>(type);
- }
-
- @SuppressWarnings("unchecked")
- private static <T extends Enum<?>> T[] values(Class<T> type) {
- try {
- return (T[]) type.getMethod("values").invoke(null);
- } catch (Exception e) {
- throw Exceptions.propagate(e);
- }
- }
-
- /** as {@link #checkAllEnumeratedIgnoreCase(String, Enum[], String...)} using the same default strategy
- * that {@link #valueOfIgnoreCase(Class, String)} applies */
- public static void checkAllEnumeratedIgnoreCase(Class<? extends Enum<?>> type, String ...explicitValues) {
- checkAllEnumeratedIgnoreCase(JavaClassNames.simpleClassName(type), values(type), explicitValues);
- }
- /** checks that all accepted enum values are represented by the given set of explicit values */
- public static void checkAllEnumeratedIgnoreCase(String contextMessage, Enum<?>[] enumValues, String ...explicitValues) {
- MutableSet<String> explicitValuesSet = MutableSet.copyOf(Iterables.transform(Arrays.asList(explicitValues), StringFunctions.toLowerCase()));
-
- Set<Enum<?>> missingEnums = MutableSet.of();
- for (Enum<?> e: enumValues) {
- if (explicitValuesSet.remove(e.name().toLowerCase())) continue;
- if (explicitValuesSet.remove(e.toString().toLowerCase())) continue;
-
- if (explicitValuesSet.remove(CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, e.name()).toLowerCase())) continue;
- if (explicitValuesSet.remove(CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, e.toString()).toLowerCase())) continue;
-
- if (explicitValuesSet.remove(CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.UPPER_CAMEL, e.toString()).toLowerCase())) continue;
- if (explicitValuesSet.remove(CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_UNDERSCORE, e.name()).toLowerCase())) continue;
-
- missingEnums.add(e);
- }
-
- if (!missingEnums.isEmpty() || !explicitValuesSet.isEmpty()) {
- throw new IllegalStateException("Not all options for "+contextMessage+" are enumerated; "
- + "leftover enums = "+missingEnums+"; "
- + "leftover values = "+explicitValuesSet);
- }
- }
-
- /** as {@link #valueOfIgnoreCase(String, Enum[], String)} for all values of the given enum and using the enum type as the message */
- public static <T extends Enum<?>> Maybe<T> valueOfIgnoreCase(Class<T> type, String givenValue) {
- return valueOfIgnoreCase(JavaClassNames.simpleClassName(type), values(type), givenValue);
- }
-
- /** attempts to match the givenValue against the given enum values, first looking for exact matches (against name and toString),
- * then matching ignoring case,
- * then matching with {@link CaseFormat#UPPER_UNDERSCORE} converted to {@link CaseFormat#LOWER_CAMEL},
- * then matching with {@link CaseFormat#LOWER_CAMEL} converted to {@link CaseFormat#UPPER_UNDERSCORE}
- * (including case insensitive matches for the final two)
- **/
- public static <T extends Enum<?>> Maybe<T> valueOfIgnoreCase(String contextMessage, T[] enumValues, String givenValue) {
- if (givenValue==null)
- return Maybe.absent(new IllegalStateException("Value for "+contextMessage+" must not be null"));
- if (Strings.isBlank(givenValue))
- return Maybe.absent(new IllegalStateException("Value for "+contextMessage+" must not be blank"));
-
- for (T v: enumValues)
- if (v.name().equals(givenValue))
- return Maybe.of(v);
- for (T v: enumValues)
- if (v.toString().equals(givenValue))
- return Maybe.of(v);
- for (T v: enumValues)
- if (v.name().equalsIgnoreCase(givenValue)) return
- Maybe.of(v);
- for (T v: enumValues)
- if (v.toString().equalsIgnoreCase(givenValue))
- return Maybe.of(v);
- for (T v: enumValues)
- if (CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, v.name()).equals(givenValue))
- return Maybe.of(v);
- for (T v: enumValues)
- if (CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, v.toString()).equals(givenValue))
- return Maybe.of(v);
- for (T v: enumValues)
- if (CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, v.name()).equalsIgnoreCase(givenValue))
- return Maybe.of(v);
- for (T v: enumValues)
- if (CaseFormat.UPPER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, v.toString()).equalsIgnoreCase(givenValue))
- return Maybe.of(v);
- for (T v: enumValues)
- if (CaseFormat.LOWER_CAMEL.to(CaseFormat.UPPER_UNDERSCORE, v.toString()).equalsIgnoreCase(givenValue))
- return Maybe.of(v);
- for (T v: enumValues)
- if (CaseFormat.LOWER_CAMEL.to(CaseFormat.UPPER_UNDERSCORE, v.name()).equals(givenValue))
- return Maybe.of(v);
- for (T v: enumValues)
- if (CaseFormat.LOWER_CAMEL.to(CaseFormat.UPPER_UNDERSCORE, v.toString()).equals(givenValue))
- return Maybe.of(v);
- for (T v: enumValues)
- if (CaseFormat.LOWER_CAMEL.to(CaseFormat.UPPER_UNDERSCORE, v.name()).equalsIgnoreCase(givenValue))
- return Maybe.of(v);
-
- return Maybe.absent(new IllegalStateException("Invalid value "+givenValue+" for "+contextMessage));
- }
-
-}
http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/cf2f7a93/utils/common/src/main/java/brooklyn/util/javalang/Equals.java
----------------------------------------------------------------------
diff --git a/utils/common/src/main/java/brooklyn/util/javalang/Equals.java b/utils/common/src/main/java/brooklyn/util/javalang/Equals.java
deleted file mode 100644
index 621d1dd..0000000
--- a/utils/common/src/main/java/brooklyn/util/javalang/Equals.java
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- * 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.util.javalang;
-
-import java.lang.reflect.Field;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import brooklyn.util.exceptions.Exceptions;
-
-import com.google.common.annotations.Beta;
-import com.google.common.base.Objects;
-
-
-public class Equals {
-
- private static final Logger log = LoggerFactory.getLogger(Equals.class);
-
- /** Tests whether the objects given are either all null or all equal to the first argument */
- public static boolean objects(Object o1, Object o2, Object... oo) {
- if (!Objects.equal(o1, o2)) return false;
- for (Object o: oo)
- if (!Objects.equal(o1, o)) return false;
- return true;
- }
-
- /** Tests whether the two objects given are either all null or all approximately equal
- * (tolerance of 0.001 for floating point, but subject to change) */
- // relatively high tolerance mainly due to enrichers such as Tomcat windowed average, in hot standby;
- // could make smaller
- @Beta
- public static boolean approximately(Object o1, Object o2) {
- if (o1 instanceof Number) {
- if (o2 instanceof Number) {
- return Math.abs( ((Number)o2).doubleValue()-((Number)o1).doubleValue() ) < 0.001;
- }
- }
- return Objects.equal(o1, o2);
- }
-
- /** As {@link #approximately(Object, Object)} but testing all the arguments given. */
- @Beta
- public static boolean approximately(Object o1, Object o2, Object o3, Object... oo) {
- if (!approximately(o1, o2)) return false;
- if (!approximately(o1, o3)) return false;
- for (Object o: oo)
- if (!approximately(o1, o)) return false;
- return true;
- }
-
- /** Useful for debugging EqualsBuilder.reflectionEquals */
- public static void dumpReflectiveEquals(Object o1, Object o2) {
- log.info("Comparing: "+o1+" "+o2);
- Class<?> clazz = o1.getClass();
- while (!(clazz.equals(Object.class))) {
- log.info(" fields in: "+clazz);
- for (Field f: clazz.getDeclaredFields()) {
- f.setAccessible(true);
- try {
- log.info( " "+(Objects.equal(f.get(o1), f.get(o2)) ? "==" : "!=" ) +
- " "+ f.getName()+ " "+ f.get(o1) +" "+ f.get(o2) +
- " ("+ classOf(f.get(o1)) +" "+ classOf(f.get(o2)+")") );
- } catch (Exception e) {
- Exceptions.propagateIfFatal(e);
- log.info( " <error> "+e);
- }
- }
- clazz = clazz.getSuperclass();
- }
- }
-
- private static String classOf(Object o) {
- if (o==null) return null;
- return o.getClass().toString();
- }
-
-}
http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/cf2f7a93/utils/common/src/main/java/brooklyn/util/javalang/JavaClassNames.java
----------------------------------------------------------------------
diff --git a/utils/common/src/main/java/brooklyn/util/javalang/JavaClassNames.java b/utils/common/src/main/java/brooklyn/util/javalang/JavaClassNames.java
deleted file mode 100644
index 1de2c46..0000000
--- a/utils/common/src/main/java/brooklyn/util/javalang/JavaClassNames.java
+++ /dev/null
@@ -1,162 +0,0 @@
-/*
- * 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.util.javalang;
-
-import brooklyn.util.net.Urls;
-import brooklyn.util.text.Strings;
-
-import com.google.common.base.Preconditions;
-import com.google.common.reflect.TypeToken;
-
-public class JavaClassNames {
-
- private static final StackTraceSimplifier STACK_TRACE_SIMPLIFIER_EXCLUDING_UTIL_JAVALANG =
- StackTraceSimplifier.newInstance(StackTraceSimplifier.class.getPackage().getName()+".");
-
- /** returns the Class of anything which isn't a class; if input is class it is pass-through */
- public static Class<?> type(Object x) {
- if (x==null) return null;
- if (x instanceof Class) return (Class<?>)x;
- if (x instanceof TypeToken) return ((TypeToken<?>)x).getRawType();
- return x.getClass();
- }
-
- /** like type, but removes any array modifiers */
- public static Class<?> componentType(Object x) {
- Class<?> c = type(x);
- if (c==null) return null;
- while (c.isArray()) {
- c = c.getComponentType();
- }
- return c;
- }
-
- /** returns a simplified name of the class, just the simple name if it seems useful, else the full name */
- public static String simpleClassName(Class<?> t) {
- int arrayCount = 0;
- while (t.isArray()) {
- arrayCount++;
- t = t.getComponentType();
- }
- Class<?> ct = componentType(t);
-
- String result = ct.getSimpleName();
- if (Strings.isBlank(result) || result.length()<=4) {
- if (ct.isPrimitive()) {
- // TODO unbox
- } else {
- result = ct.getName();
- }
- }
- return result+Strings.repeat("[]", arrayCount);
- }
-
- /** as {@link #simpleClassName(Class)} but taking the type of the object if it is not already a class
- * or a type-token; callers should usually do the getClass themselves, unless they aren't sure whether
- * it is already a Class-type object */
- public static String simpleClassName(Object x) {
- if (x==null) return null;
- return simpleClassName(type(x));
- }
-
- /** as {@link #simpleClassName(Class)} but taking a string rep'n of the class name,
- * and doing best effort to simplify it (without instantiating) */
- public static String simplifyClassName(String className) {
- if (className==null) return null;
- int lastDot = className.lastIndexOf('.');
- if (lastDot < className.length()-5)
- return className.substring(lastDot+1);
- return className;
- }
-
- /** as {@link #simpleClassName(Object)} but making the result clean for use on filesystems and as java identifiers */
- public static String cleanSimpleClassName(Object x) {
- return Strings.makeValidFilename(simpleClassName(x));
- }
-
- /** as {@link #simpleClassName(Object)} but making the result clean for use on filesystems and as java identifiers */
- public static String cleanSimpleClassName(Class<?> x) {
- return Strings.makeValidFilename(simpleClassName(x));
- }
-
- public static String packageName(Object x) {
- return componentType(x).getPackage().getName();
- }
-
- /** returns e.g. "/com/acme/" for an object in package com.acme */
- public static String packagePath(Object x) {
- return Urls.mergePaths("/", componentType(x).getPackage().getName().replace('.', '/'), "/");
- }
-
- /** returns path relative to the package of x, unless path is absolute.
- * useful to mimic Class.getResource(path) behaviour, cf Class.resolveName where the first argument below is the class. */
- public static String resolveName(Object context, String path) {
- Preconditions.checkNotNull(path, "path must not be null");
- if (path.startsWith("/") || Urls.isUrlWithProtocol(path)) return path;
- Preconditions.checkNotNull(context, "context must not be null when path is relative");
- return packagePath(context)+path;
- }
-
- /** returns a "classpath:" URL given a context object and a file to be found in that directory or a sub-directory
- * (ignoring the context object if the given path is absolute, i.e. starting with "/" or "protocol:")
- * e.g. "classpath://com/acme/foo.txt" given a context object com.acme.SomeClass and "foo.txt" */
- public static String resolveClasspathUrl(Object context, String path) {
- if (Urls.isUrlWithProtocol(path)) return path;
- // additional / comes from resolve name
- return "classpath:/"+resolveName(context, path);
- }
-
- /** returns a cleaned stack trace; caller is usually at the top */
- public static StackTraceElement[] currentStackTraceCleaned() {
- return STACK_TRACE_SIMPLIFIER_EXCLUDING_UTIL_JAVALANG.clean(
- Thread.currentThread().getStackTrace());
- }
-
- /** returns top of cleaned stack trace; usually the caller's location */
- public static StackTraceElement currentStackElement() {
- return STACK_TRACE_SIMPLIFIER_EXCLUDING_UTIL_JAVALANG.nthUseful(0,
- Thread.currentThread().getStackTrace());
- }
-
- /** returns element in cleaned stack trace; usually the caller's location is at the top,
- * and caller of that is up one, etc */
- public static StackTraceElement callerStackElement(int depth) {
- return STACK_TRACE_SIMPLIFIER_EXCLUDING_UTIL_JAVALANG.nthUseful(depth,
- Thread.currentThread().getStackTrace());
- }
-
- /** returns nice class name and method for the given element */
- public static String niceClassAndMethod(StackTraceElement st) {
- return simplifyClassName(st.getClassName())+"."+st.getMethodName();
- }
-
- /** returns nice class name and method for the caller, going up the stack (filtered to remove invocation etc),
- * with 0 typically being the context where this method is called, 1 being its caller, etc */
- public static String callerNiceClassAndMethod(int depth) {
- return niceClassAndMethod(callerStackElement(depth));
- }
-
- /** convenience for {@link #callerNiceClassAndMethod(int)} with depth 0
- * <p>
- * useful for tests and other debug-facing log messages! */
- public static String niceClassAndMethod() {
- return callerNiceClassAndMethod(0);
- }
-
-}
http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/cf2f7a93/utils/common/src/main/java/brooklyn/util/javalang/LoadedClassLoader.java
----------------------------------------------------------------------
diff --git a/utils/common/src/main/java/brooklyn/util/javalang/LoadedClassLoader.java b/utils/common/src/main/java/brooklyn/util/javalang/LoadedClassLoader.java
deleted file mode 100644
index cef27ab..0000000
--- a/utils/common/src/main/java/brooklyn/util/javalang/LoadedClassLoader.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * 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.util.javalang;
-
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-/** a classloader which allows you to register classes and resources which this loader will return when needed,
- * (essentially a registry rather than a classloader, but useful if you need to make new classes available in
- * an old context) */
-public class LoadedClassLoader extends ClassLoader {
-
- Map<String, Class<?>> loadedClasses = new LinkedHashMap<String, Class<?>>();
-
- protected synchronized Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
- Class<?> result = loadedClasses.get(name);
- if (result==null) throw new ClassNotFoundException(""+name+" not known here");
- if (resolve) resolveClass(result);
- return result;
- }
-
- public void addClass(Class<?> clazz) {
- loadedClasses.put(clazz.getName(), clazz);
- }
-
- // TODO could also add resources
-
-}
http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/cf2f7a93/utils/common/src/main/java/brooklyn/util/javalang/MemoryUsageTracker.java
----------------------------------------------------------------------
diff --git a/utils/common/src/main/java/brooklyn/util/javalang/MemoryUsageTracker.java b/utils/common/src/main/java/brooklyn/util/javalang/MemoryUsageTracker.java
deleted file mode 100644
index e8bb896..0000000
--- a/utils/common/src/main/java/brooklyn/util/javalang/MemoryUsageTracker.java
+++ /dev/null
@@ -1,72 +0,0 @@
-/*
- * 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.util.javalang;
-
-import java.lang.ref.SoftReference;
-import java.lang.ref.WeakReference;
-import java.util.concurrent.atomic.AtomicLong;
-
-import com.google.common.cache.Cache;
-import com.google.common.cache.CacheBuilder;
-import com.google.common.cache.RemovalListener;
-import com.google.common.cache.RemovalNotification;
-
-/**
- * Tracks the amount of memory consumed by the given objects in use.
- * <p>
- * {@link WeakReference}s are used internally, so that shortly after a {@link #track(Object, long)}ed object is GC'd,
- * the {@link #getBytesUsed()} value decrements appropriately.
- */
-public class MemoryUsageTracker {
-
- /**
- * Shared instance for use for tracking memory used by {@link SoftReference}.
- * <p>
- * Callers should only use this field to {@link #track(Object, long)} objects which have (or will soon have)
- * given up their strong references, so that only soft or weak references remain.
- * Provided size estimates are accurate, {@link #getBytesUsed()} will report
- * the amount of used memory which is reclaimable by collecting soft references.
- * <p>
- * This is particularly handy for tracking {@link SoftReference}s, because otherwise you can quickly get to a state
- * where {@link Runtime#freeMemory()} looks very low.
- **/
- public static final MemoryUsageTracker SOFT_REFERENCES = new MemoryUsageTracker();
-
- AtomicLong bytesUsed = new AtomicLong(0);
-
- Cache<Object, Long> memoryTrackedReferences = CacheBuilder.newBuilder()
- .weakKeys()
- .removalListener(new RemovalListener<Object,Long>() {
- @Override
- public void onRemoval(RemovalNotification<Object, Long> notification) {
- bytesUsed.addAndGet(-notification.getValue());
- }
- }).build();
-
- public void track(Object instance, long bytesUsedByInstance) {
- bytesUsed.addAndGet(bytesUsedByInstance);
- memoryTrackedReferences.put(instance, bytesUsedByInstance);
- }
-
- public long getBytesUsed() {
- memoryTrackedReferences.cleanUp();
- return bytesUsed.get();
- }
-
-}
http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/cf2f7a93/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
deleted file mode 100644
index 7db91d4..0000000
--- a/utils/common/src/main/java/brooklyn/util/javalang/Reflections.java
+++ /dev/null
@@ -1,789 +0,0 @@
-/*
- * 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.util.javalang;
-
-import static com.google.common.base.Preconditions.checkNotNull;
-
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-import java.lang.reflect.Array;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
-import java.net.URL;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.HashSet;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.Stack;
-
-import javax.annotation.Nullable;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import brooklyn.util.collections.MutableList;
-import brooklyn.util.exceptions.Exceptions;
-
-import com.google.common.base.Optional;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Predicate;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.Sets;
-
-/**
- * Reflection utilities ("borrowed" from cloudsoft monterey).
- *
- * @author aled
- */
-public class Reflections {
-
- private static final Logger LOG = LoggerFactory.getLogger(Reflections.class);
-
- public static class ReflectionNotFoundException extends RuntimeException {
- private static final long serialVersionUID = 9032835250796708037L;
- public ReflectionNotFoundException(String message, Throwable cause) {
- super(message, cause);
- }
- public ReflectionNotFoundException(String message) {
- super(message);
- }
- }
-
- public static class ReflectionAccessException extends RuntimeException {
- private static final long serialVersionUID = 6569605861192432009L;
-
- public ReflectionAccessException(String message, Throwable cause) {
- super(message, cause);
- }
- }
-
- private final ClassLoader classLoader;
-
- public Reflections(ClassLoader classLoader) {
- this.classLoader = checkNotNull(classLoader);
- }
-
- public Object loadInstance(String classname, Object...argValues) throws ReflectionNotFoundException, ReflectionAccessException {
- Class<?> clazz = loadClass(classname);
- Optional<?> v = null;
- try {
- v = invokeConstructorWithArgs(clazz, argValues);
- if (v.isPresent()) return v.get();
- } catch (Exception e) {
- throw new IllegalStateException("Error invoking constructor for "+clazz+Arrays.toString(argValues) + ": " + Exceptions.collapseText(e));
- }
- throw new IllegalStateException("No suitable constructor for "+clazz+Arrays.toString(argValues));
- }
- public Object loadInstance(String classname, Class<?>[] argTypes, Object[] argValues) throws ReflectionNotFoundException, ReflectionAccessException {
- Class<?> clazz = loadClass(classname);
- Constructor<?> constructor = loadConstructor(clazz, argTypes);
- return loadInstance(constructor, argValues);
- }
-
- public Object loadInstance(String classname) throws ReflectionNotFoundException, ReflectionAccessException {
- Class<?> clazz = loadClass(classname);
- try {
- return clazz.newInstance();
- } catch (InstantiationException e) {
- throw new ReflectionAccessException("Failed to create instance of class '" + classname + "' using class loader " + classLoader + ": " + Exceptions.collapseText(e), e);
- } catch (IllegalAccessException e) {
- throw new ReflectionAccessException("Failed to create instance of class '" + classname + "' using class loader " + classLoader + ": " + Exceptions.collapseText(e), e);
- }
- }
-
- /** instantiates the given class from its binary name */
- public Class<?> loadClass(String classname) throws ReflectionNotFoundException {
- try {
- return classLoader.loadClass(classname);
- } catch (ClassNotFoundException e) {
- throw new ReflectionNotFoundException("Failed to load class '" + classname + "' using class loader " + classLoader + ": " + Exceptions.collapseText(e), e);
- } catch (NoClassDefFoundError e) {
- throw new ReflectionNotFoundException("Failed to load class '" + classname + "' using class loader " + classLoader + ": " + Exceptions.collapseText(e), e);
- } catch (UnsupportedClassVersionError e) {
- throw new ReflectionNotFoundException("Failed to load class '" + classname + "' using class loader " + classLoader + ": " + Exceptions.collapseText(e), e);
- }
- }
-
- @SuppressWarnings("unchecked")
- public <T> Class<? extends T> loadClass(String classname, Class<T> superType) throws ReflectionNotFoundException {
- return (Class<? extends T>) loadClass(classname);
- }
-
- /** given a nested part, e.g. Inner$VeryInner, this will recurse through clazz.Inner, looking for VeryInner,
- * then looking in each supertype (interface) of clazz for Inner.VeryInner;
- * <p>
- * so it will find Clazz.Inner.VeryInner wherever in the hierarchy it is defined
- * <p>
- * (as opposed to ClassLoader which requires Inner.VeryInner to be _declared_ in clazz, not in any supertype
- * <p>
- * returns null if not found
- */
- public static Class<?> loadInnerClassPossiblyInheritted(Class<?> clazz, String nestedPart) throws ReflectionNotFoundException {
- Set<String> visited = new HashSet<String>();
- Class<?> result = loadInnerClassPossiblyInheritted(visited, clazz, nestedPart);
- if (result!=null) return result;
- throw new ReflectionNotFoundException("Inner class " + nestedPart + " could not be found in " + clazz + " or any of its super-types");
- }
-
- /** as 2-arg, but maintains set of visited elements, and returns null if not found */
- private static Class<?> loadInnerClassPossiblyInheritted(Set<String> visited, Class<?> clazz, String nestedPart) throws ReflectionNotFoundException {
- if (clazz==null) return null;
- if (nestedPart==null || nestedPart.length()==0) return clazz;
-
- int i1 = nestedPart.indexOf('$');
- int i2 = nestedPart.indexOf('.');
- int idx = (i2 > -1 && (i2 < i1 || i1==-1) ? i2 : i1);
- String thisClassToFind = nestedPart;
- String nextClassesToFind = "";
- if (idx>=0) {
- thisClassToFind = nestedPart.substring(0, idx);
- nextClassesToFind = nestedPart.substring(idx+1);
- }
-
- if (!visited.add(clazz.getCanonicalName()+"!"+nestedPart)) {
- //already visited
- return null;
- }
-
- Class<?>[] members = clazz.getClasses();
- for (int i = 0; i < members.length; i++) {
- if (members[i].getSimpleName().equals(thisClassToFind)) {
- Class<?> clazzI = loadInnerClassPossiblyInheritted(visited, members[i], nextClassesToFind);
- if (clazzI!=null) return clazzI;
- }
- }
-
- //look in supertype first (not sure if necessary)
- Class<?> result = loadInnerClassPossiblyInheritted(visited, clazz.getSuperclass(), nestedPart);
- if (result!=null) return result;
-
- for (Class<?> iface : clazz.getInterfaces()) {
- result = loadInnerClassPossiblyInheritted(visited, iface, nestedPart);
- if (result!=null) return result;
- }
- return null;
- }
-
- /** does not look through ancestors of outer class */
- public Class<?> loadInnerClassNotInheritted(String outerClassname, String innerClassname) throws ReflectionNotFoundException {
- return loadClass(outerClassname + "$" + innerClassname);
- }
-
- /** does not look through ancestors of outer class
- * <p>
- * uses the classloader set in this class, not in the clazz supplied */
- public Class<?> loadInnerClassNotInheritted(Class<?> outerClazz, String innerClassname) throws ReflectionNotFoundException {
- return loadClass(outerClazz.getName() + "$" + innerClassname);
- }
-
- public Constructor<?> loadConstructor(Class<?> clazz, Class<?>[] argTypes) throws ReflectionAccessException {
- try {
- return clazz.getConstructor(argTypes);
- } catch (SecurityException e) {
- throw new ReflectionAccessException("Failed to load constructor of class '" + clazz + " with argument types " + Arrays.asList(argTypes) + ": " + Exceptions.collapseText(e), e);
- } catch (NoSuchMethodException e) {
- throw new ReflectionAccessException("Failed to load constructor of class '" + clazz + " with argument types " + Arrays.asList(argTypes) + ": " + Exceptions.collapseText(e), e);
- }
- }
-
- /** Invokes a suitable constructor, supporting varargs and primitives */
- public static <T> Optional<T> invokeConstructorWithArgs(ClassLoader classLoader, String className, Object...argsArray) {
- Reflections reflections = new Reflections(classLoader);
- @SuppressWarnings("unchecked")
- Class<T> clazz = (Class<T>) reflections.loadClass(className);
- return invokeConstructorWithArgs(reflections, clazz, argsArray, false);
- }
-
- /** Invokes a suitable constructor, supporting varargs and primitives */
- public static <T> Optional<T> invokeConstructorWithArgs(ClassLoader classLoader, Class<T> clazz, Object[] argsArray, boolean setAccessible) {
- Reflections reflections = new Reflections(classLoader);
- return invokeConstructorWithArgs(reflections, clazz, argsArray, setAccessible);
- }
-
- /** Invokes a suitable constructor, supporting varargs and primitives */
- public static <T> Optional<T> invokeConstructorWithArgs(Class<T> clazz, Object...argsArray) {
- return invokeConstructorWithArgs(clazz, argsArray, false);
- }
-
- /** Invokes a suitable constructor, supporting varargs and primitives */
- public static <T> Optional<T> invokeConstructorWithArgs(Class<T> clazz, Object[] argsArray, boolean setAccessible) {
- Reflections reflections = new Reflections(clazz.getClassLoader());
- return invokeConstructorWithArgs(reflections, clazz, argsArray, setAccessible);
- }
-
- /** Invokes a suitable constructor, supporting varargs and primitives, additionally supporting setAccessible */
- @SuppressWarnings("unchecked")
- public static <T> Optional<T> invokeConstructorWithArgs(Reflections reflections, Class<T> clazz, Object[] argsArray, boolean setAccessible) {
- for (Constructor<?> constructor : clazz.getConstructors()) {
- Class<?>[] parameterTypes = constructor.getParameterTypes();
- if (constructor.isVarArgs()) {
- if (typesMatchUpTo(argsArray, parameterTypes, parameterTypes.length-1)) {
- Class<?> varargType = parameterTypes[parameterTypes.length-1].getComponentType();
- boolean varargsMatch = true;
- for (int i=parameterTypes.length-1; i<argsArray.length; i++) {
- if (!Boxing.boxedType(varargType).isInstance(argsArray[i]) ||
- (varargType.isPrimitive() && argsArray[i]==null)) {
- varargsMatch = false;
- break;
- }
- }
- if (varargsMatch) {
- Object varargs = Array.newInstance(varargType, argsArray.length+1 - parameterTypes.length);
- for (int i=parameterTypes.length-1; i<argsArray.length; i++) {
- Boxing.setInArray(varargs, i+1-parameterTypes.length, argsArray[i], varargType);
- }
- Object[] newArgsArray = new Object[parameterTypes.length];
- System.arraycopy(argsArray, 0, newArgsArray, 0, parameterTypes.length-1);
- newArgsArray[parameterTypes.length-1] = varargs;
- if (setAccessible) constructor.setAccessible(true);
- return (Optional<T>) Optional.of(reflections.loadInstance(constructor, newArgsArray));
- }
- }
- }
- if (typesMatch(argsArray, parameterTypes)) {
- if (setAccessible) constructor.setAccessible(true);
- return (Optional<T>) Optional.of(reflections.loadInstance(constructor, argsArray));
- }
- }
- return Optional.absent();
- }
-
-
- /** returns a single constructor in a given class, or throws an exception */
- public Constructor<?> loadSingleConstructor(Class<?> clazz) {
- Constructor<?>[] constructors = clazz.getConstructors();
- if (constructors.length == 1) {
- return constructors[0];
- }
- throw new IllegalArgumentException("Class " + clazz + " has more than one constructor");
- }
-
- public <T> T loadInstance(Constructor<T> constructor, Object...argValues) throws IllegalArgumentException, ReflectionAccessException {
- try {
- try {
- return constructor.newInstance(argValues);
- } catch (IllegalArgumentException e) {
- try {
- LOG.warn("Failure passing provided arguments ("+getIllegalArgumentsErrorMessage(constructor, argValues)+"; "+e+"); attempting to reconstitute");
- argValues = (Object[]) updateFromNewClassLoader(argValues);
- return constructor.newInstance(argValues);
- } catch (Throwable e2) {
- LOG.warn("Reconstitution attempt failed (will rethrow original excaption): "+e2, e2);
- throw e;
- }
- }
- } catch (IllegalArgumentException e) {
- throw new IllegalArgumentException(getIllegalArgumentsErrorMessage(constructor, argValues)+": " + Exceptions.collapseText(e), e);
- } catch (InstantiationException e) {
- throw new ReflectionAccessException("Failed to create instance of " + constructor.getDeclaringClass() + ": " + Exceptions.collapseText(e), e);
- } catch (IllegalAccessException e) {
- throw new ReflectionAccessException("Failed to create instance of " + constructor.getDeclaringClass() + ": " + Exceptions.collapseText(e), e);
- } catch (InvocationTargetException e) {
- throw new ReflectionAccessException("Failed to create instance of " + constructor.getDeclaringClass() + ": " + Exceptions.collapseText(e), e);
- }
- }
-
- public Method loadMethod(Class<?> clazz, String methodName, Class<?>[] argTypes) throws ReflectionNotFoundException, ReflectionAccessException {
- try {
- return clazz.getMethod(methodName, argTypes);
- } catch (NoClassDefFoundError e) {
- throw new ReflectionNotFoundException("Failed to invoke method " + methodName + " on class " + clazz + " with argument types " + Arrays.asList(argTypes) + ", using class loader " + clazz.getClassLoader() + ": " + Exceptions.collapseText(e), e);
- } catch (NoSuchMethodException e) {
- throw new ReflectionNotFoundException("Failed to invoke method " + methodName + " on class " + clazz + " with argument types " + Arrays.asList(argTypes) + ": " + Exceptions.collapseText(e), e);
- } catch (SecurityException e) {
- throw new ReflectionAccessException("Failed to invoke method " + methodName + " on class " + clazz + " with argument types " + Arrays.asList(argTypes) + ": " + Exceptions.collapseText(e), e);
- }
- }
-
- /** returns the first method matching the given name */
- public Method loadMethod(Class<?> clazz, String methodName) throws ReflectionNotFoundException, ReflectionAccessException {
- try {
- Method[] allmethods = clazz.getMethods();
- for (int i = 0; i < allmethods.length; i++) {
- if (allmethods[i].getName().equals(methodName)) {
- return allmethods[i];
- }
- }
- throw new ReflectionNotFoundException("Cannot find method " + methodName + " on class " + clazz);
-
- } catch (SecurityException e) {
- throw new ReflectionAccessException("Failed to invoke method '" + methodName + " on class " + clazz + ": " + Exceptions.collapseText(e), e);
- }
- }
-
- /**
- *
- * @throws ReflectionAccessException If invocation failed due to illegal access or the invoked method failed
- * @throws IllegalArgumentException If the arguments were invalid
- */
- public Object invokeMethod(Method method, Object obj, Object... argValues) throws ReflectionAccessException {
- try {
- return method.invoke(obj, argValues);
- } catch (IllegalArgumentException e) {
- throw new IllegalArgumentException(getIllegalArgumentsErrorMessage(method, argValues), e);
- } catch (IllegalAccessException e) {
- throw new ReflectionAccessException("Failed to invoke method '" + method.toGenericString() + " on class " + method.getDeclaringClass() + " with argument values " + Arrays.asList(argValues) + ": " + Exceptions.collapseText(e), e);
- } catch (InvocationTargetException e) {
- throw new ReflectionAccessException("Failed to invoke method '" + method.toGenericString() + " on class " + method.getDeclaringClass() + " with argument values " + Arrays.asList(argValues) + ": " + Exceptions.collapseText(e), e);
- }
- }
-
- public Object invokeStaticMethod(Method method, Object... argValues) throws IllegalArgumentException, ReflectionAccessException {
- try {
- return method.invoke(null, argValues);
- } catch (IllegalArgumentException e) {
- throw new IllegalArgumentException(getIllegalArgumentsErrorMessage(method, argValues), e);
- } catch (IllegalAccessException e) {
- throw new ReflectionAccessException("Failed to invoke method '" + method.toGenericString() + " on class " + method.getDeclaringClass() + " with argument values " + Arrays.asList(argValues) + ": " + Exceptions.collapseText(e), e);
- } catch (InvocationTargetException e) {
- throw new ReflectionAccessException("Failed to invoke method '" + method.toGenericString() + " on class " + method.getDeclaringClass() + " with argument values " + Arrays.asList(argValues) + ": " + Exceptions.collapseText(e), e);
- }
- }
-
- public Object loadStaticField(Class<?> clazz, String fieldname) throws ReflectionAccessException {
- return loadStaticFields(clazz, new String[] {fieldname}, null)[0];
- }
-
- public Object[] loadStaticFields(Class<?> clazz, String[] fieldnamesArray, Object[] defaults) throws ReflectionAccessException {
- Object[] result = new Object[fieldnamesArray.length];
- if (defaults!=null) {
- for (int i = 0; i < defaults.length; i++) {
- result[i] = defaults[i];
- }
- }
-
- List<String> fieldnames = Arrays.asList(fieldnamesArray);
- Field[] classFields = clazz.getDeclaredFields();
-
- for (int i = 0; i < classFields.length; i++) {
- Field field = classFields[i];
- int index = fieldnames.indexOf(field.getName());
- if (index >= 0) {
- try {
- result[index] = field.get(null);
- } catch (IllegalArgumentException e) {
- throw new ReflectionAccessException("Failed to load field '" + field.getName() + " from class " + clazz + ": " + Exceptions.collapseText(e), e);
- } catch (IllegalAccessException e) {
- throw new ReflectionAccessException("Failed to load field '" + field.getName() + " from class " + clazz + ": " + Exceptions.collapseText(e), e);
- }
- }
- }
- return result;
- }
-
- private static String getIllegalArgumentsErrorMessage(Method method, Object[] argValues) {
- return method.toGenericString() + " not applicable for the parameters of type " + argumentTypesToString(argValues);
- }
-
- private static String getIllegalArgumentsErrorMessage(Constructor<?> constructor, Object[] argValues) {
- return constructor.toGenericString() + " not applicable for the parameters of type " + argumentTypesToString(argValues);
- }
-
- private static String argumentTypesToString(Object[] argValues) {
- StringBuffer msg = new StringBuffer("(");
- for (int i = 0; i < argValues.length; i++) {
- if (i != 0) msg.append(", ");
- msg.append(argValues[i] != null ? argValues[i].getClass().getName() : "null");
- }
- msg.append(")");
- return msg.toString();
- }
-
- /** copies all fields from the source to target; very little compile-time safety checking, so use with care
- * @throws IllegalAccessException
- * @throws IllegalArgumentException */
- public static <T> void copyFields(T source, T target) throws IllegalArgumentException, IllegalAccessException {
- Class<? extends Object> clazz = source.getClass();
- while (clazz!=null) {
- Field[] fields = clazz.getDeclaredFields();
- for (Field f : fields) {
- f.setAccessible(true);
- Object vs = f.get(source);
- Object vt = f.get(target);
- if ((vs==null && vt!=null) || (vs!=null && !vs.equals(vt))) {
- f.set(target, vs);
- }
- }
- clazz = clazz.getSuperclass();
- }
- }
-
- /**
- * Loads class given its canonical name format (e.g. com.acme.Foo.Inner),
- * using iterative strategy (trying com.acme.Foo$Inner, then com.acme$Foo$Inner, etc).
- * @throws ReflectionNotFoundException
- */
- public Class<?> loadClassFromCanonicalName(String canonicalName) throws ClassNotFoundException, ReflectionNotFoundException {
- ClassNotFoundException err = null;
- String name = canonicalName;
- do {
- try {
- return classLoader.loadClass(name);
- } catch (ClassNotFoundException e) {
- if (err == null) err = e;
- int lastIndexOf = name.lastIndexOf(".");
- if (lastIndexOf >= 0) {
- name = name.substring(0, lastIndexOf) + "$" + name.substring(lastIndexOf+1);
- }
- }
- } while (name.contains("."));
- throw err;
- }
-
- /** finds the resource in the classloader, if it exists; inserts or replaces leading slash as necessary
- * (i believe it should _not_ have one, but there is some inconsistency)
- *
- * Will return null if no resource is found.
- */
- @Nullable
- public URL getResource(String r) {
- URL u = null;
- u = classLoader.getResource(r);
- if (u!=null) return u;
-
- if (r.startsWith("/")) r = r.substring(1);
- else r = "/"+r;
- return classLoader.getResource(r);
- }
-
- /**
- * Serialize the given object, then reload using the current class loader;
- * this removes linkages to instances with classes loaded by an older class loader.
- * <p>
- * (like a poor man's clone)
- * <p>
- * aka "reconstitute(Object)"
- */
- public final Object updateFromNewClassLoader(Object data) throws IOException, ClassNotFoundException {
- ByteArrayOutputStream bytes = new ByteArrayOutputStream();
- new ObjectOutputStream(bytes).writeObject(data);
- Object reconstituted = new ObjectInputStream(new ByteArrayInputStream(bytes.toByteArray())).readObject();
- if (LOG.isDebugEnabled()) LOG.debug("Reconstituted data: " + reconstituted + ", class loader: " + classLoader);
- return reconstituted;
- }
-
- public ClassLoader getClassLoader() {
- return classLoader;
- }
-
- @SuppressWarnings("unchecked")
- public static <T> Class<? super T> findSuperType(T impl, String typeName) {
- Set<Class<?>> toinspect = new LinkedHashSet<Class<?>>();
- Set<Class<?>> inspected = new HashSet<Class<?>>();
- toinspect.add(impl.getClass());
-
- while (toinspect.size() > 0) {
- Class<?> clazz = toinspect.iterator().next(); // get and remove the first element
- if (clazz.getName().equals(typeName)) {
- return (Class<? super T>) clazz;
- }
- inspected.add(clazz);
- List<Class<?>> toAdd = Arrays.asList(clazz.getInterfaces());
- toinspect.addAll( toAdd );
- if (clazz.getSuperclass() != null) toinspect.add(clazz.getSuperclass());
- toinspect.removeAll(inspected);
- }
-
- return null;
- }
-
- /** whereas Class.getInterfaces() only returns interfaces directly implemented by a class,
- * this walks the inheritance hierarchy to include interfaces implemented by superclass/ancestors;
- * (note it does not include superinterfaces)
- */
- public static Set<Class<?>> getInterfacesIncludingClassAncestors(Class<?> clazz) {
- Set<Class<?>> result = new LinkedHashSet<Class<?>>();
- while (clazz!=null) {
- for (Class<?> iface: clazz.getInterfaces())
- result.add(iface);
- clazz = clazz.getSuperclass();
- }
- return result;
- }
-
- public static Method findMethod(Class<?> clazz, String name, Class<?>... parameterTypes) throws NoSuchMethodException {
- if (clazz == null || name == null) {
- throw new NullPointerException("Must not be null: clazz="+clazz+"; name="+name);
- }
- Class<?> clazzToInspect = clazz;
- NoSuchMethodException toThrowIfFails = null;
-
- while (clazzToInspect != null) {
- try {
- return clazzToInspect.getDeclaredMethod(name, parameterTypes);
- } catch (NoSuchMethodException e) {
- if (toThrowIfFails == null) toThrowIfFails = e;
- clazzToInspect = clazzToInspect.getSuperclass();
- }
- }
- throw toThrowIfFails;
- }
-
- public static Field findField(Class<?> clazz, String name) throws NoSuchFieldException {
- if (clazz == null || name == null) {
- throw new NullPointerException("Must not be null: clazz="+clazz+"; name="+name);
- }
- Class<?> clazzToInspect = clazz;
- NoSuchFieldException toThrowIfFails = null;
-
- while (clazzToInspect != null) {
- try {
- return clazzToInspect.getDeclaredField(name);
- } catch (NoSuchFieldException e) {
- if (toThrowIfFails == null) toThrowIfFails = e;
- clazzToInspect = clazzToInspect.getSuperclass();
- }
- }
- throw toThrowIfFails;
- }
-
- public static List<Field> findPublicFieldsOrderedBySuper(Class<?> clazz) {
- checkNotNull(clazz, "clazz");
- MutableList.Builder<Field> result = MutableList.<Field>builder();
- Stack<Class<?>> tovisit = new Stack<Class<?>>();
- Set<Class<?>> visited = Sets.newLinkedHashSet();
- tovisit.push(clazz);
-
- while (!tovisit.isEmpty()) {
- Class<?> nextclazz = tovisit.pop();
- if (!visited.add(nextclazz)) {
- continue; // already visited
- }
- if (nextclazz.getSuperclass() != null) tovisit.add(nextclazz.getSuperclass());
- tovisit.addAll(Arrays.asList(nextclazz.getInterfaces()));
-
- result.addAll(Iterables.filter(Arrays.asList(nextclazz.getDeclaredFields()), new Predicate<Field>() {
- @Override public boolean apply(Field input) {
- return Modifier.isPublic(input.getModifiers());
- }}));
-
- }
-
- List<Field> resultList = result.build();
- Collections.sort(resultList, new Comparator<Field>() {
- @Override public int compare(Field f1, Field f2) {
- Field fsubbest = inferSubbestField(f1, f2);
- return (fsubbest == null) ? 0 : (fsubbest == f1 ? 1 : -1);
- }});
-
- return resultList;
- }
-
- // TODO I've seen strange behaviour where class.getMethods() does not include methods from interfaces.
- // Also the ordering guarantees here are useful...
- public static List<Method> findPublicMethodsOrderedBySuper(Class<?> clazz) {
- checkNotNull(clazz, "clazz");
- MutableList.Builder<Method> result = MutableList.<Method>builder();
- Stack<Class<?>> tovisit = new Stack<Class<?>>();
- Set<Class<?>> visited = Sets.newLinkedHashSet();
- tovisit.push(clazz);
-
- while (!tovisit.isEmpty()) {
- Class<?> nextclazz = tovisit.pop();
- if (!visited.add(nextclazz)) {
- continue; // already visited
- }
- if (nextclazz.getSuperclass() != null) tovisit.add(nextclazz.getSuperclass());
- tovisit.addAll(Arrays.asList(nextclazz.getInterfaces()));
-
- result.addAll(Iterables.filter(Arrays.asList(nextclazz.getDeclaredMethods()), new Predicate<Method>() {
- @Override public boolean apply(Method input) {
- return Modifier.isPublic(input.getModifiers());
- }}));
-
- }
-
- List<Method> resultList = result.build();
- Collections.sort(resultList, new Comparator<Method>() {
- @Override public int compare(Method m1, Method m2) {
- Method msubbest = inferSubbestMethod(m1, m2);
- return (msubbest == null) ? 0 : (msubbest == m1 ? 1 : -1);
- }});
-
- return resultList;
- }
-
- /**
- * Gets the field that is in the sub-class; or null if one field does not come from a sub-class of the other field's class
- */
- public static Field inferSubbestField(Field f1, Field f2) {
- Class<?> c1 = f1.getDeclaringClass();
- Class<?> c2 = f2.getDeclaringClass();
- boolean isSuper1 = c1.isAssignableFrom(c2);
- boolean isSuper2 = c2.isAssignableFrom(c1);
- return (isSuper1) ? (isSuper2 ? null : f2) : (isSuper2 ? f1 : null);
- }
-
- /**
- * Gets the method that is in the sub-class; or null if one method does not come from a sub-class of the other method's class
- */
- public static Method inferSubbestMethod(Method m1, Method m2) {
- Class<?> c1 = m1.getDeclaringClass();
- Class<?> c2 = m2.getDeclaringClass();
- boolean isSuper1 = c1.isAssignableFrom(c2);
- boolean isSuper2 = c2.isAssignableFrom(c1);
- return (isSuper1) ? (isSuper2 ? null : m2) : (isSuper2 ? m1 : null);
- }
-
- /**
- * Gets the class that is in the sub-class; or null if neither is a sub-class of the other.
- */
- public static Class<?> inferSubbest(Class<?> c1, Class<?> c2) {
- boolean isSuper1 = c1.isAssignableFrom(c2);
- boolean isSuper2 = c2.isAssignableFrom(c1);
- return (isSuper1) ? (isSuper2 ? null : c2) : (isSuper2 ? c1 : null);
- }
-
- /** convenience for casting the given candidate to the given type (without any coercion, and allowing candidate to be null) */
- @SuppressWarnings("unchecked")
- public static <T> T cast(Object candidate, Class<? extends T> type) {
- if (candidate==null) return null;
- if (!type.isAssignableFrom(candidate.getClass()))
- throw new IllegalArgumentException("Requires a "+type+", but had a "+candidate.getClass()+" ("+candidate+")");
- return (T)candidate;
- }
-
- /** invokes the given method on the given clazz or instance, doing reasonably good matching on args etc
- * @throws InvocationTargetException
- * @throws IllegalAccessException
- * @throws IllegalArgumentException */
- public static Optional<Object> invokeMethodWithArgs(Object clazzOrInstance, String method, List<Object> args) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {
- return invokeMethodWithArgs(clazzOrInstance, method, args, false);
- }
- public static Optional<Object> invokeMethodWithArgs(Object clazzOrInstance, String method, List<Object> args, boolean setAccessible) throws IllegalArgumentException, IllegalAccessException, InvocationTargetException {
- Preconditions.checkNotNull(clazzOrInstance, "clazz or instance");
- Preconditions.checkNotNull(method, "method");
- Preconditions.checkNotNull(args, "args to "+method);
-
- Class<?> clazz;
- Object instance;
- if (clazzOrInstance instanceof Class) {
- clazz = (Class<?>)clazzOrInstance;
- instance = null;
- } else {
- clazz = clazzOrInstance.getClass();
- instance = clazzOrInstance;
- }
-
- Object[] argsArray = args.toArray();
-
- for (Method m: clazz.getMethods()) {
- if (method.equals(m.getName())) {
- Class<?>[] parameterTypes = m.getParameterTypes();
- if (m.isVarArgs()) {
- if (typesMatchUpTo(argsArray, parameterTypes, parameterTypes.length-1)) {
- Class<?> varargType = parameterTypes[parameterTypes.length-1].getComponentType();
- boolean varargsMatch = true;
- for (int i=parameterTypes.length-1; i<argsArray.length; i++) {
- if (!Boxing.boxedType(varargType).isInstance(argsArray[i]) ||
- (varargType.isPrimitive() && argsArray[i]==null)) {
- varargsMatch = false;
- break;
- }
- }
- if (varargsMatch) {
- Object varargs = Array.newInstance(varargType, argsArray.length+1 - parameterTypes.length);
- for (int i=parameterTypes.length-1; i<argsArray.length; i++) {
- Boxing.setInArray(varargs, i+1-parameterTypes.length, argsArray[i], varargType);
- }
- Object[] newArgsArray = new Object[parameterTypes.length];
- System.arraycopy(argsArray, 0, newArgsArray, 0, parameterTypes.length-1);
- newArgsArray[parameterTypes.length-1] = varargs;
- if (setAccessible) m.setAccessible(true);
- return Optional.of(m.invoke(instance, newArgsArray));
- }
- }
- }
- if (typesMatch(argsArray, parameterTypes)) {
- if (setAccessible) m.setAccessible(true);
- return Optional.of(m.invoke(instance, argsArray));
- }
- }
- }
-
- return Optional.absent();
- }
-
- /** true iff all args match the corresponding types */
- public static boolean typesMatch(Object[] argsArray, Class<?>[] parameterTypes) {
- if (argsArray.length != parameterTypes.length)
- return false;
- return typesMatchUpTo(argsArray, parameterTypes, argsArray.length);
- }
-
- /** true iff the initial N args match the corresponding types */
- public static boolean typesMatchUpTo(Object[] argsArray, Class<?>[] parameterTypes, int lengthRequired) {
- if (argsArray.length < lengthRequired || parameterTypes.length < lengthRequired)
- return false;
- for (int i=0; i<lengthRequired; i++) {
- if (argsArray[i]==null) continue;
- if (Boxing.boxedType(parameterTypes[i]).isInstance(argsArray[i])) continue;
- return false;
- }
- return true;
- }
-
- /**
- * Gets all the interfaces implemented by the given type, including its parent classes.
- *
- * @param type the class to look up
- * @return an immutable list of the interface classes
- */
- public static List<Class<?>> getAllInterfaces(@Nullable Class<?> type) {
- Set<Class<?>> found = Sets.newLinkedHashSet();
- findAllInterfaces(type, found);
- return ImmutableList.copyOf(found);
- }
-
- /** Recurse through the class hierarchies of the type and its interfaces. */
- private static void findAllInterfaces(@Nullable Class<?> type, Set<Class<?>> found) {
- if (type == null) return;
- for (Class<?> i : type.getInterfaces()) {
- if (found.add(i)) { // not seen before
- findAllInterfaces(i, found);
- }
- }
- findAllInterfaces(type.getSuperclass(), found);
- }
-
- public static boolean hasNoArgConstructor(Class<?> clazz) {
- try {
- clazz.getConstructor(new Class[0]);
- return true;
- } catch (NoSuchMethodException e) {
- 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/cf2f7a93/utils/common/src/main/java/brooklyn/util/javalang/Serializers.java
----------------------------------------------------------------------
diff --git a/utils/common/src/main/java/brooklyn/util/javalang/Serializers.java b/utils/common/src/main/java/brooklyn/util/javalang/Serializers.java
deleted file mode 100644
index b16229f..0000000
--- a/utils/common/src/main/java/brooklyn/util/javalang/Serializers.java
+++ /dev/null
@@ -1,121 +0,0 @@
-/*
- * 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.util.javalang;
-
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
-import java.io.ObjectStreamClass;
-import java.io.OutputStream;
-
-import brooklyn.util.stream.Streams;
-
-public class Serializers {
-
- public interface ObjectReplacer {
- public static final ObjectReplacer NOOP = new ObjectReplacer() {
- @Override public Object replace(Object toserialize) {
- return toserialize;
- }
- @Override public Object resolve(Object todeserialize) {
- return todeserialize;
- }
- };
-
- public Object replace(Object toserialize);
- public Object resolve(Object todeserialize);
- }
-
- public static <T> T reconstitute(T object) throws IOException, ClassNotFoundException {
- return reconstitute(object, ObjectReplacer.NOOP);
- }
-
- public static <T> T reconstitute(T object, ObjectReplacer replacer) throws IOException, ClassNotFoundException {
- if (object == null) return null;
- return reconstitute(object, object.getClass().getClassLoader(), replacer);
- }
-
- public static <T> T reconstitute(T object, ClassLoader classLoader) throws IOException, ClassNotFoundException {
- return reconstitute(object, classLoader, ObjectReplacer.NOOP);
- }
-
- @SuppressWarnings("unchecked")
- public static <T> T reconstitute(T object, ClassLoader classLoader, final ObjectReplacer replacer) throws IOException, ClassNotFoundException {
- if (object == null) return null;
-
- class ReconstitutingObjectOutputStream extends ObjectOutputStream {
- public ReconstitutingObjectOutputStream(OutputStream outputStream) throws IOException {
- super(outputStream);
- enableReplaceObject(true);
- }
- @Override
- protected Object replaceObject(Object obj) throws IOException {
- return replacer.replace(obj);
- }
- };
- ByteArrayOutputStream baos = new ByteArrayOutputStream();
- ObjectOutputStream oos = new ReconstitutingObjectOutputStream(baos);
- oos.writeObject(object);
- oos.close();
-
- class ReconstitutingObjectInputStream extends ClassLoaderObjectInputStream {
- public ReconstitutingObjectInputStream(InputStream inputStream, ClassLoader classLoader) throws IOException {
- super(inputStream, classLoader);
- super.enableResolveObject(true);
- }
- @Override protected Object resolveObject(Object obj) throws IOException {
- return replacer.resolve(obj);
- }
- };
- ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
- ReconstitutingObjectInputStream ois = new ReconstitutingObjectInputStream(bais, classLoader);
- try {
- return (T) ois.readObject();
- } finally {
- Streams.closeQuietly(ois);
- }
- }
-
- /**
- * Follows pattern in org.apache.commons.io.input.ClassLoaderObjectInputStream
- */
- public static class ClassLoaderObjectInputStream extends ObjectInputStream {
-
- private final ClassLoader classLoader;
-
- public ClassLoaderObjectInputStream(InputStream inputStream, ClassLoader classLoader) throws IOException {
- super(inputStream);
- this.classLoader = classLoader;
- }
-
- @Override
- protected Class<?> resolveClass(ObjectStreamClass objectStreamClass) throws IOException, ClassNotFoundException {
- Class<?> clazz = Class.forName(objectStreamClass.getName(), false, classLoader);
-
- if (clazz != null) {
- return clazz;
- } else {
- return super.resolveClass(objectStreamClass);
- }
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/cf2f7a93/utils/common/src/main/java/brooklyn/util/javalang/StackTraceSimplifier.java
----------------------------------------------------------------------
diff --git a/utils/common/src/main/java/brooklyn/util/javalang/StackTraceSimplifier.java b/utils/common/src/main/java/brooklyn/util/javalang/StackTraceSimplifier.java
deleted file mode 100644
index 283cb98..0000000
--- a/utils/common/src/main/java/brooklyn/util/javalang/StackTraceSimplifier.java
+++ /dev/null
@@ -1,203 +0,0 @@
-/*
- * 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.util.javalang;
-
-import java.io.PrintWriter;
-import java.io.StringWriter;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.List;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import brooklyn.util.text.Strings;
-
-import com.google.common.annotations.Beta;
-import com.google.common.collect.ImmutableSet;
-
-/**
- * Utility class for cleaning up stacktraces.
- */
-public class StackTraceSimplifier {
-
- private static final Logger log = LoggerFactory.getLogger(StackTraceSimplifier.class);
-
- /** comma-separated prefixes (not regexes) */
- public static final String DEFAULT_BLACKLIST_SYSTEM_PROPERTY_NAME = "brooklyn.util.javalang.StackTraceSimplifier.blacklist";
-
- /** @deprecated since 0.6.0 use {@link #DEFAULT_BLACKLIST_SYSTEM_PROPERTY_NAME} */ @Deprecated
- public static final String LEGACY_DEFAULT_BLACKLIST_SYSTEM_PROPERTY_NAME = "groovy.sanitized.stacktraces";
-
- private static final Collection<String> DEFAULT_BLACKLIST;
-
- static {
- ImmutableSet.Builder<String> blacklist = ImmutableSet.builder();
- blacklist.addAll(Arrays.asList(
- System.getProperty(DEFAULT_BLACKLIST_SYSTEM_PROPERTY_NAME,
- "java.," +
- "javax.," +
- "sun.," +
- "groovy.," +
- "org.codehaus.groovy.," +
- "gjdk.groovy.,"
- ).split("(\\s|,)+")));
-
- String legacyDefaults = System.getProperty(LEGACY_DEFAULT_BLACKLIST_SYSTEM_PROPERTY_NAME);
- if (Strings.isNonBlank(legacyDefaults)) {
- log.warn("Detected ude of legacy system property "+LEGACY_DEFAULT_BLACKLIST_SYSTEM_PROPERTY_NAME);
- blacklist.addAll(Arrays.asList(legacyDefaults.split("(\\s|,)+")));
- }
-
- DEFAULT_BLACKLIST = blacklist.build();
- }
-
- private static final StackTraceSimplifier DEFAULT_INSTACE = newInstance();
-
- private final Collection<String> blacklist;
-
- protected StackTraceSimplifier() {
- this(true);
- }
-
- protected StackTraceSimplifier(boolean includeDefaultBlacklist, String ...packages) {
- ImmutableSet.Builder<String> blacklistB = ImmutableSet.builder();
- if (includeDefaultBlacklist)
- blacklistB.addAll(DEFAULT_BLACKLIST);
- blacklistB.add(packages);
- blacklist = blacklistB.build();
- }
-
- public static StackTraceSimplifier newInstance() {
- return new StackTraceSimplifier();
- }
-
- public static StackTraceSimplifier newInstance(String ...additionalBlacklistPackagePrefixes) {
- return new StackTraceSimplifier(true, additionalBlacklistPackagePrefixes);
- }
-
- public static StackTraceSimplifier newInstanceExcludingOnly(String ...blacklistPackagePrefixes) {
- return new StackTraceSimplifier(false, blacklistPackagePrefixes);
- }
-
- /** @return whether the given element is useful, that is, not in the blacklist */
- public boolean isUseful(StackTraceElement el) {
- for (String s: blacklist){
- if (el.getClassName().startsWith(s)) return false;;
- // gets underscores in some contexts ?
- if (el.getClassName().replace('_', '.').startsWith(s)) return false;
- }
-
- return true;
- }
-
- /** @return new list containing just the {@link #isUseful(StackTraceElement)} stack trace elements */
- public List<StackTraceElement> clean(Iterable<StackTraceElement> st) {
- List<StackTraceElement> result = new LinkedList<StackTraceElement>();
- for (StackTraceElement element: st){
- if (isUseful(element)){
- result.add(element);
- }
- }
-
- return result;
- }
-
- /** @return new array containing just the {@link #isUseful(StackTraceElement)} stack trace elements */
- public StackTraceElement[] clean(StackTraceElement[] st) {
- List<StackTraceElement> result = clean(Arrays.asList(st));
- return result.toArray(new StackTraceElement[result.size()]);
- }
-
- /** @return first {@link #isUseful(StackTraceElement)} stack trace elements, or null */
- public StackTraceElement firstUseful(StackTraceElement[] st) {
- return nthUseful(0, st);
- }
-
- /** @return (n+1)th {@link #isUseful(StackTraceElement)} stack trace elements (ie 0 is {@link #firstUseful(StackTraceElement[])}), or null */
- public StackTraceElement nthUseful(int n, StackTraceElement[] st) {
- for (StackTraceElement element: st){
- if (isUseful(element)) {
- if (n==0)
- return element;
- n--;
- }
- }
- return null;
- }
-
- /** {@link #clean(StackTraceElement[])} the given throwable instance, returning the same instance for convenience */
- public <T extends Throwable> T cleaned(T t) {
- t.setStackTrace(clean(t.getStackTrace()));
- return t;
- }
-
- // ---- statics
-
- /** static convenience for {@link #isUseful(StackTraceElement)} */
- public static boolean isStackTraceElementUseful(StackTraceElement el) {
- return DEFAULT_INSTACE.isUseful(el);
- }
-
- /** static convenience for {@link #clean(Iterable)} */
- public static List<StackTraceElement> cleanStackTrace(Iterable<StackTraceElement> st) {
- return DEFAULT_INSTACE.clean(st);
- }
-
- /** static convenience for {@link #clean(StackTraceElement[])} */
- public static StackTraceElement[] cleanStackTrace(StackTraceElement[] st) {
- return DEFAULT_INSTACE.clean(st);
- }
-
- /** static convenience for {@link #cleaned(Throwable)} */
- public static <T extends Throwable> T cleanedStackTrace(T t) {
- return DEFAULT_INSTACE.cleaned(t);
- }
-
- public static String toString(Throwable t) {
- StringWriter sw = new StringWriter();
- PrintWriter pw = new PrintWriter(sw);
- t.printStackTrace(pw);
- return sw.getBuffer().toString();
- }
-
- /** returns the number of times the calling method occurs elsewhere in the stack trace;
- * 0 if no recursion, 1 if it has cycled three times, etc. */
- @Beta // useful to track down things like https://github.com/apache/incubator-brooklyn/pull/489
- public static int getRecursiveCallCount() {
- StackTraceElement[] t = cleanStackTrace(new Throwable().getStackTrace());
- Iterator<StackTraceElement> ti = Arrays.asList(t).iterator();
- ti.next();
- if (!ti.hasNext()) return 0;
- // t0 is the caller
- StackTraceElement t0 = ti.next();
- String l0 = t0.getClassName()+"."+t0.getMethodName()+"("+t0.getFileName()+")";
- int count = 0;
- while (ti.hasNext()) {
- StackTraceElement ta = ti.next();
- String li = ta.getClassName()+"."+ta.getMethodName()+"("+ta.getFileName()+")";
- // if we have something in a different method, then something back in the method
- // from which the recursive check came, then return true
- if (li.equals(l0)) count++;
- }
- return count;
- }
-}
http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/cf2f7a93/utils/common/src/main/java/brooklyn/util/javalang/Threads.java
----------------------------------------------------------------------
diff --git a/utils/common/src/main/java/brooklyn/util/javalang/Threads.java b/utils/common/src/main/java/brooklyn/util/javalang/Threads.java
deleted file mode 100644
index b3af17b..0000000
--- a/utils/common/src/main/java/brooklyn/util/javalang/Threads.java
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * 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.util.javalang;
-
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import brooklyn.util.exceptions.Exceptions;
-
-public class Threads {
-
- private static final Logger log = LoggerFactory.getLogger(Threads.class);
-
- public static Thread addShutdownHook(final Runnable task) {
- Thread t = new Thread("shutdownHookThread") {
- public void run() {
- try {
- task.run();
- } catch (Exception e) {
- log.error("Failed to execute shutdownhook", e);
- }
- }
- };
- Runtime.getRuntime().addShutdownHook(t);
- return t;
- }
-
- public static boolean removeShutdownHook(Thread hook) {
- try {
- return Runtime.getRuntime().removeShutdownHook(hook);
- } catch (IllegalStateException e) {
- // probably shutdown in progress
- String text = Exceptions.collapseText(e);
- if (text.contains("Shutdown in progress")) {
- if (log.isTraceEnabled()) {
- log.trace("Could not remove shutdown hook "+hook+": "+text);
- }
- } else {
- log.warn("Could not remove shutdown hook "+hook+": "+text);
- log.debug("Shutdown hook removal details: "+e, e);
- }
- return false;
- }
- }
-
-}
http://git-wip-us.apache.org/repos/asf/incubator-brooklyn/blob/cf2f7a93/utils/common/src/main/java/brooklyn/util/logging/LoggingSetup.java
----------------------------------------------------------------------
diff --git a/utils/common/src/main/java/brooklyn/util/logging/LoggingSetup.java b/utils/common/src/main/java/brooklyn/util/logging/LoggingSetup.java
deleted file mode 100644
index ba89426..0000000
--- a/utils/common/src/main/java/brooklyn/util/logging/LoggingSetup.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * 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.util.logging;
-
-import org.slf4j.bridge.SLF4JBridgeHandler;
-
-public class LoggingSetup {
-
- /** bridge java.util.logging messages to slf4j
- * <p>
- * without this, we get ugly java.util.logging messages on the console and _not_ in the file;
- * with this, the excludes rules (which route the common j.u.l categories to the file _only_)
- * will apply to j.u.l loggers
- * <p>
- * typically this is invoked in a static block on a class (in tests and in BrooklynWebServer)
- * or could be done on app startup */
- public static void installJavaUtilLoggingBridge() {
- SLF4JBridgeHandler.removeHandlersForRootLogger();
- SLF4JBridgeHandler.install();
- }
-
-
-}