// adds offline mode from system property
private Settings enrichWithOfflineMode(Settings settings) {
String goOffline = SecurityActions.getProperty(ALT_MAVEN_OFFLINE);
if (goOffline != null && goOffline.length() > 0) {
settings.setOffline(Boolean.valueOf(goOffline));
}
return settings;
}
/**
* Loads default Maven settings from standard location or from a location specified by a property
*
* @return
*/
public Settings buildDefaultSettings() {
SettingsBuildingRequest request =
new DefaultSettingsBuildingRequest().setSystemProperties(SecurityActions.getProperties());
String altUserSettings = SecurityActions.getProperty(ALT_USER_SETTINGS_XML_LOCATION);
String altGlobalSettings = SecurityActions.getProperty(ALT_GLOBAL_SETTINGS_XML_LOCATION);
request.setUserSettingsFile(new File(DEFAULT_USER_SETTINGS_PATH));
// set alternate files
if (altUserSettings != null && altUserSettings.length() > 0) {
request.setUserSettingsFile(new File(altUserSettings));
}
if (altGlobalSettings != null && altGlobalSettings.length() > 0) {
request.setGlobalSettingsFile(new File(altGlobalSettings));
}
return buildSettings(request);
}
// adds local repository
private Settings enrichWithLocalRepository(Settings settings) {
// set default value if not set at all
if (settings.getLocalRepository() == null || settings.getLocalRepository().length() == 0) {
settings.setLocalRepository(DEFAULT_REPOSITORY_PATH);
}
// override any value with system property based location
String altLocalRepository = SecurityActions.getProperty(ALT_LOCAL_REPOSITORY_LOCATION);
if (altLocalRepository != null && altLocalRepository.length() > 0) {
settings.setLocalRepository(altLocalRepository);
}
return settings;
}
/** * Builds Maven settings from arbitrary settings.xml file * * @author <a href="mailto:[email protected]">Karel Piwko</a> */ public class MavenSettingsBuilder { private static Logger log = Logger.getLogger(MavenSettingsBuilder.class.getName()); /** Sets an alternate location to Maven user settings.xml configuration */ public static final String ALT_USER_SETTINGS_XML_LOCATION = "org.apache.maven.user-settings"; /** Sets an alternate location of Maven global settings.xml configuration */ public static final String ALT_GLOBAL_SETTINGS_XML_LOCATION = "org.apache.maven.global-settings"; /** Sets Maven resolution either online or offline */ public static final String ALT_MAVEN_OFFLINE = "org.apache.maven.offline"; /** Sets an alternate location of Maven local repository */ public static final String ALT_LOCAL_REPOSITORY_LOCATION = "maven.repo.local"; // path to the user settings.xml private static final String DEFAULT_USER_SETTINGS_PATH = SecurityActions.getProperty("user.home").concat("/.m2/settings.xml"); // path to the default local repository private static final String DEFAULT_REPOSITORY_PATH = SecurityActions.getProperty("user.home").concat("/.m2/repository"); /** * Loads default Maven settings from standard location or from a location specified by a property * * @return */ public Settings buildDefaultSettings() { SettingsBuildingRequest request = new DefaultSettingsBuildingRequest().setSystemProperties(SecurityActions.getProperties()); String altUserSettings = SecurityActions.getProperty(ALT_USER_SETTINGS_XML_LOCATION); String altGlobalSettings = SecurityActions.getProperty(ALT_GLOBAL_SETTINGS_XML_LOCATION); request.setUserSettingsFile(new File(DEFAULT_USER_SETTINGS_PATH)); // set alternate files if (altUserSettings != null && altUserSettings.length() > 0) { request.setUserSettingsFile(new File(altUserSettings)); } if (altGlobalSettings != null && altGlobalSettings.length() > 0) { request.setGlobalSettingsFile(new File(altGlobalSettings)); } return buildSettings(request); } /** * Builds Maven settings from request. * * @param request The request for new settings */ public Settings buildSettings(SettingsBuildingRequest request) { SettingsBuildingResult result; try { SettingsBuilder builder = new DefaultSettingsBuilderFactory().newInstance(); if (request.getGlobalSettingsFile() != null) { if (log.isLoggable(Level.FINE)) { log.fine( "Using " + request.getGlobalSettingsFile().getAbsolutePath() + " to get global Maven settings.xml"); } } final File userSettingsFile = request.getUserSettingsFile(); if (userSettingsFile != null) { if (log.isLoggable(Level.FINE)) { log.fine( "Using " + userSettingsFile.getAbsolutePath() + " to get user Maven settings.xml"); } // Maven will not check the format passed in (any XML will do), so let's ensure we have a // settings.xml by checking just the top-level element final XMLStreamReader reader; try { reader = XMLInputFactory.newInstance() .createXMLStreamReader(new FileInputStream(userSettingsFile)); // get the first element name while (reader.hasNext()) { if (reader.next() == XMLStreamConstants.START_ELEMENT) { break; } } final String topLevel = reader.getLocalName(); if (!"settings".equals(topLevel)) { throw new InvalidConfigurationFileException( "Invalid format settings.xml found: " + userSettingsFile); } } catch (final FileNotFoundException e) { // Ignore at this level } catch (final XMLStreamException xmlse) { throw new RuntimeException( "Could not check file format of specified settings.xml: " + userSettingsFile, xmlse); } } result = builder.build(request); } // wrap exception message catch (SettingsBuildingException e) { StringBuilder sb = new StringBuilder("Found ") .append(e.getProblems().size()) .append( " problems while building settings.xml model from both global Maven configuration file") .append(request.getGlobalSettingsFile()) .append(" and/or user configuration file: ") .append(request.getUserSettingsFile()) .append("\n"); int counter = 1; for (SettingsProblem problem : e.getProblems()) { sb.append(counter++).append("/ ").append(problem).append("\n"); } throw new InvalidConfigurationFileException(sb.toString()); } // get settings object and update it according to property values Settings settings = result.getEffectiveSettings(); settings = enrichWithLocalRepository(settings); settings = enrichWithOfflineMode(settings); return settings; } // adds local repository private Settings enrichWithLocalRepository(Settings settings) { // set default value if not set at all if (settings.getLocalRepository() == null || settings.getLocalRepository().length() == 0) { settings.setLocalRepository(DEFAULT_REPOSITORY_PATH); } // override any value with system property based location String altLocalRepository = SecurityActions.getProperty(ALT_LOCAL_REPOSITORY_LOCATION); if (altLocalRepository != null && altLocalRepository.length() > 0) { settings.setLocalRepository(altLocalRepository); } return settings; } // adds offline mode from system property private Settings enrichWithOfflineMode(Settings settings) { String goOffline = SecurityActions.getProperty(ALT_MAVEN_OFFLINE); if (goOffline != null && goOffline.length() > 0) { settings.setOffline(Boolean.valueOf(goOffline)); } return settings; } }
/**
* Creates a builder which has access to Maven system and current settings
*
* @param system the Maven system
* @param settings Maven and resolver settings
*/
MavenManagerBuilder(RepositorySystem system, Settings settings) {
this.system = system;
this.settings = settings;
this.useLegacyLocalRepository =
Boolean.parseBoolean(SecurityActions.getProperty(USE_LEGACY_REPO_KEY));
}
/**
* General utility methods used throughout the Infinispan code base.
*
* @author <a href="*****@*****.**">Brian Stansberry</a>
* @author Galder Zamarreño
* @since 4.0
*/
public final class Util {
private static final boolean IS_ARRAYS_DEBUG = Boolean.getBoolean("infinispan.arrays.debug");
private static final boolean IS_OSGI_CONTEXT;
public static final Object[] EMPTY_OBJECT_ARRAY = new Object[0];
public static final byte[] EMPTY_BYTE_ARRAY = new byte[0];
private static final Log log = LogFactory.getLog(Util.class);
/**
* Current Java vendor. This variable is later used to differentiate LRU implementations for
* different java vendors.
*/
private static final String javaVendor = SecurityActions.getProperty("java.vendor", "");
static {
boolean osgi = false;
try {
osgi = Util.class.getClassLoader() instanceof org.osgi.framework.BundleReference;
} catch (NoClassDefFoundError ex) {
// Ignore
}
IS_OSGI_CONTEXT = osgi;
}
/**
* Loads the specified class using the passed classloader, or, if it is <code>null</code> the
* Infinispan classes' classloader.
*
* <p>If loadtime instrumentation via GenerateInstrumentedClassLoader is used, this class may be
* loaded by the bootstrap classloader.
*
* <p>If the class is not found, the {@link ClassNotFoundException} or {@link
* NoClassDefFoundError} is wrapped as a {@link CacheConfigurationException} and is re-thrown.
*
* @param classname name of the class to load
* @param cl the application classloader which should be used to load the class, or null if the
* class is always packaged with Infinispan
* @return the class
* @throws CacheConfigurationException if the class cannot be loaded
*/
public static <T> Class<T> loadClass(String classname, ClassLoader cl) {
try {
return loadClassStrict(classname, cl);
} catch (ClassNotFoundException e) {
throw new CacheConfigurationException("Unable to instantiate class " + classname, e);
}
}
/**
* Tries to determine if the code is running in an OSGi context.
*
* @return true if an OSGi context is detected
*/
public static boolean isOSGiContext() {
return IS_OSGI_CONTEXT;
}
public static ClassLoader[] getClassLoaders(ClassLoader appClassLoader) {
if (isOSGiContext()) {
return new ClassLoader[] {
appClassLoader, // User defined classes
OsgiClassLoader
.getInstance(), // OSGi bundle context needs to be on top of TCCL, system CL, etc.
Util.class.getClassLoader(), // Infinispan classes (not always on TCCL [modular env])
ClassLoader.getSystemClassLoader(), // Used when load time instrumentation is in effect
Thread.currentThread().getContextClassLoader() // Used by jboss-as stuff
};
} else {
return new ClassLoader[] {
appClassLoader, // User defined classes
Util.class.getClassLoader(), // Infinispan classes (not always on TCCL [modular env])
ClassLoader.getSystemClassLoader(), // Used when load time instrumentation is in effect
Thread.currentThread().getContextClassLoader() // Used by jboss-as stuff
};
}
}
/**
* Loads the specified class using the passed classloader, or, if it is <code>null</code> the
* Infinispan classes' classloader.
*
* <p>If loadtime instrumentation via GenerateInstrumentedClassLoader is used, this class may be
* loaded by the bootstrap classloader.
*
* @param classname name of the class to load
* @return the class
* @param userClassLoader the application classloader which should be used to load the class, or
* null if the class is always packaged with Infinispan
* @throws ClassNotFoundException if the class cannot be loaded
*/
@SuppressWarnings("unchecked")
public static <T> Class<T> loadClassStrict(String classname, ClassLoader userClassLoader)
throws ClassNotFoundException {
ClassLoader[] cls = getClassLoaders(userClassLoader);
ClassNotFoundException e = null;
NoClassDefFoundError ne = null;
for (ClassLoader cl : cls) {
if (cl == null) continue;
try {
return (Class<T>) Class.forName(classname, true, cl);
} catch (ClassNotFoundException ce) {
e = ce;
} catch (NoClassDefFoundError ce) {
ne = ce;
}
}
if (e != null) throw e;
else if (ne != null) {
// Before we wrap this, make sure we appropriately log this.
log.unableToLoadClass(classname, Arrays.toString(cls), ne);
throw new ClassNotFoundException(classname, ne);
} else throw new IllegalStateException();
}
public static InputStream getResourceAsStream(String resourcePath, ClassLoader userClassLoader) {
if (resourcePath.startsWith("/")) {
resourcePath = resourcePath.substring(1);
}
InputStream is = null;
for (ClassLoader cl : getClassLoaders(userClassLoader)) {
if (cl != null) {
is = cl.getResourceAsStream(resourcePath);
if (is != null) {
break;
}
}
}
return is;
}
private static Method getFactoryMethod(Class<?> c) {
for (Method m : c.getMethods()) {
if (m.getName().equals("getInstance")
&& m.getParameterTypes().length == 0
&& Modifier.isStatic(m.getModifiers())) return m;
}
return null;
}
/**
* Instantiates a class by first attempting a static <i>factory method</i> named
* <tt>getInstance()</tt> on the class and then falling back to an empty constructor.
*
* <p>Any exceptions encountered are wrapped in a {@link CacheConfigurationException} and
* rethrown.
*
* @param clazz class to instantiate
* @return an instance of the class
*/
public static <T> T getInstance(Class<T> clazz) {
try {
return getInstanceStrict(clazz);
} catch (IllegalAccessException iae) {
throw new CacheConfigurationException("Unable to instantiate class " + clazz.getName(), iae);
} catch (InstantiationException ie) {
throw new CacheConfigurationException("Unable to instantiate class " + clazz.getName(), ie);
}
}
/**
* Similar to {@link #getInstance(Class)} except that exceptions are propagated to the caller.
*
* @param clazz class to instantiate
* @return an instance of the class
* @throws IllegalAccessException
* @throws InstantiationException
*/
@SuppressWarnings("unchecked")
public static <T> T getInstanceStrict(Class<T> clazz)
throws IllegalAccessException, InstantiationException {
// first look for a getInstance() constructor
T instance = null;
try {
Method factoryMethod = getFactoryMethod(clazz);
if (factoryMethod != null) instance = (T) factoryMethod.invoke(null);
} catch (Exception e) {
// no factory method or factory method failed. Try a constructor.
instance = null;
}
if (instance == null) {
instance = clazz.newInstance();
}
return instance;
}
/**
* Instantiates a class based on the class name provided. Instantiation is attempted via an
* appropriate, static factory method named <tt>getInstance()</tt> first, and failing the
* existence of an appropriate factory, falls back to an empty constructor.
*
* <p>Any exceptions encountered loading and instantiating the class is wrapped in a {@link
* CacheConfigurationException}.
*
* @param classname class to instantiate
* @return an instance of classname
*/
public static <T> T getInstance(String classname, ClassLoader cl) {
if (classname == null) throw new IllegalArgumentException("Cannot load null class!");
Class<T> clazz = loadClass(classname, cl);
return getInstance(clazz);
}
/**
* Similar to {@link #getInstance(String, ClassLoader)} except that exceptions are propagated to
* the caller.
*
* @param classname class to instantiate
* @return an instance of classname
* @throws ClassNotFoundException
* @throws InstantiationException
* @throws IllegalAccessException
*/
public static <T> T getInstanceStrict(String classname, ClassLoader cl)
throws ClassNotFoundException, InstantiationException, IllegalAccessException {
if (classname == null) throw new IllegalArgumentException("Cannot load null class!");
Class<T> clazz = loadClassStrict(classname, cl);
return getInstanceStrict(clazz);
}
/**
* Clones parameter x of type T with a given Marshaller reference;
*
* @return a deep clone of an object parameter x
*/
@SuppressWarnings("unchecked")
public static <T> T cloneWithMarshaller(Marshaller marshaller, T x) {
if (marshaller == null)
throw new IllegalArgumentException("Cannot use null Marshaller for clone");
byte[] byteBuffer;
try {
byteBuffer = marshaller.objectToByteBuffer(x);
return (T) marshaller.objectFromByteBuffer(byteBuffer);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new CacheException(e);
} catch (Exception e) {
throw new CacheException(e);
}
}
/** Prevent instantiation */
private Util() {}
/**
* Null-safe equality test.
*
* @param a first object to compare
* @param b second object to compare
* @return true if the objects are equals or both null, false otherwise.
*/
public static boolean safeEquals(Object a, Object b) {
return (a == b) || (a != null && a.equals(b));
}
public static String prettyPrintTime(long time, TimeUnit unit) {
return prettyPrintTime(unit.toMillis(time));
}
/**
* {@link System#nanoTime()} is less expensive than {@link System#currentTimeMillis()} and better
* suited to measure time intervals. It's NOT suited to know the current time, for example to be
* compared with the time of other nodes.
*
* @return the value of {@link System#nanoTime()}, but converted in Milliseconds.
*/
public static final long currentMillisFromNanotime() {
return TimeUnit.MILLISECONDS.convert(System.nanoTime(), TimeUnit.NANOSECONDS);
}
/**
* Prints a time for display
*
* @param millis time in millis
* @return the time, represented as millis, seconds, minutes or hours as appropriate, with suffix
*/
public static String prettyPrintTime(long millis) {
if (millis < 1000) return millis + " milliseconds";
NumberFormat nf = NumberFormat.getNumberInstance();
nf.setMaximumFractionDigits(2);
double toPrint = ((double) millis) / 1000;
if (toPrint < 300) {
return nf.format(toPrint) + " seconds";
}
toPrint = toPrint / 60;
if (toPrint < 120) {
return nf.format(toPrint) + " minutes";
}
toPrint = toPrint / 60;
return nf.format(toPrint) + " hours";
}
/**
* Reads the given InputStream fully, closes the stream and returns the result as a byte array.
*
* @param is the stream to read
* @return the read bytes
* @throws java.io.IOException in case of stream read errors
*/
public static byte[] readStream(InputStream is) throws IOException {
try {
ByteArrayOutputStream os = new ByteArrayOutputStream();
byte[] buf = new byte[1024];
int len;
while ((len = is.read(buf)) != -1) {
os.write(buf, 0, len);
}
return os.toByteArray();
} finally {
is.close();
}
}
/**
* Reads the given InputStream fully, closes the stream and returns the result as a String.
*
* @param is the stream to read
* @return the UTF-8 string
* @throws java.io.IOException in case of stream read errors
*/
public static String read(InputStream is) throws IOException {
try {
final Reader reader = new InputStreamReader(is, "UTF-8");
StringWriter writer = new StringWriter();
char[] buf = new char[1024];
int len;
while ((len = reader.read(buf)) != -1) {
writer.write(buf, 0, len);
}
return writer.toString();
} finally {
is.close();
}
}
public static void close(Closeable cl) {
if (cl == null) return;
try {
cl.close();
} catch (Exception e) {
}
}
public static void close(Socket s) {
if (s == null) return;
try {
s.close();
} catch (Exception e) {
}
}
public static void close(Closeable... cls) {
for (Closeable cl : cls) {
close(cl);
}
}
public static void close(Context ctx) {
if (ctx == null) return;
try {
ctx.close();
} catch (Exception e) {
}
}
public static void flushAndCloseStream(OutputStream o) {
if (o == null) return;
try {
o.flush();
} catch (Exception e) {
}
try {
o.close();
} catch (Exception e) {
}
}
public static void flushAndCloseOutput(ObjectOutput o) {
if (o == null) return;
try {
o.flush();
} catch (Exception e) {
}
try {
o.close();
} catch (Exception e) {
}
}
public static String formatString(Object message, Object... params) {
if (params.length == 0) return message == null ? "null" : message.toString();
return String.format(message.toString(), params);
}
public static String toStr(Object o) {
if (o instanceof byte[]) {
return printArray((byte[]) o, false);
} else if (o == null) {
return "null";
} else {
return o.toString();
}
}
public static <E> String toStr(Collection<E> collection) {
if (collection == null) return "[]";
Iterator<E> i = collection.iterator();
if (!i.hasNext()) return "[]";
StringBuilder sb = new StringBuilder();
sb.append('[');
for (; ; ) {
E e = i.next();
sb.append(e == collection ? "(this Collection)" : toStr(e));
if (!i.hasNext()) return sb.append(']').toString();
sb.append(", ");
}
}
public static String printArray(byte[] array) {
return printArray(array, false);
}
public static String printArray(byte[] array, boolean withHash) {
if (array == null) return "null";
int limit = 8;
StringBuilder sb = new StringBuilder();
sb.append("[B0x");
if (array.length <= limit || IS_ARRAYS_DEBUG) {
// Convert the entire byte array
sb.append(toHexString(array));
if (withHash) {
sb.append(",h=");
sb.append(Integer.toHexString(Arrays.hashCode(array)));
sb.append(']');
}
} else {
// Pick the first 8 characters and convert that part
sb.append(toHexString(array, limit));
sb.append("..[");
sb.append(array.length);
if (withHash) {
sb.append("],h=");
sb.append(Integer.toHexString(Arrays.hashCode(array)));
}
sb.append(']');
}
return sb.toString();
}
public static String toHexString(byte input[]) {
return toHexString(input, input.length);
}
public static String toHexString(byte input[], int limit) {
int i = 0;
if (input == null || input.length <= 0) return null;
char lookup[] = {
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
};
char[] result = new char[(input.length < limit ? input.length : limit) * 2];
while (i < limit && i < input.length) {
result[2 * i] = lookup[(input[i] >> 4) & 0x0F];
result[2 * i + 1] = lookup[(input[i] & 0x0F)];
i++;
}
return String.valueOf(result);
}
public static String padString(String s, int minWidth) {
if (s.length() < minWidth) {
StringBuilder sb = new StringBuilder(s);
while (sb.length() < minWidth) sb.append(" ");
return sb.toString();
}
return s;
}
private static String INDENT = " ";
public static String threadDump() {
StringBuilder threadDump = new StringBuilder();
ThreadMXBean threadMx = ManagementFactory.getThreadMXBean();
if (threadMx.isObjectMonitorUsageSupported() && threadMx.isSynchronizerUsageSupported()) {
// Print lock info if, and only if, both object monitor usage and synchronizer usage are
// supported.
dumpThreadInfo(threadDump, true, threadMx);
} else {
dumpThreadInfo(threadDump, false, threadMx);
}
return threadDump.toString();
}
private static void dumpThreadInfo(
StringBuilder threadDump, boolean withLocks, ThreadMXBean threadMx) {
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String timestamp = dateFormat.format(new Date());
threadDump.append(timestamp);
threadDump.append("\nFull thread dump ");
threadDump.append("\n");
if (withLocks) {
ThreadInfo[] threadInfos = threadMx.dumpAllThreads(true, true);
for (ThreadInfo threadInfo : threadInfos) {
printThreadInfo(threadInfo, threadDump);
LockInfo[] syncs = threadInfo.getLockedSynchronizers();
printLockInfo(syncs, threadDump);
}
threadDump.append("\n");
} else {
long[] threadIds = threadMx.getAllThreadIds();
ThreadInfo[] threadInfos = threadMx.getThreadInfo(threadIds, Integer.MAX_VALUE);
for (ThreadInfo threadInfo : threadInfos) printThreadInfo(threadInfo, threadDump);
}
}
private static void printThreadInfo(ThreadInfo threadInfo, StringBuilder threadDump) {
// Print thread information
printThread(threadInfo, threadDump);
// print stack trace with locks
StackTraceElement[] stacktrace = threadInfo.getStackTrace();
MonitorInfo[] monitors = threadInfo.getLockedMonitors();
for (int i = 0; i < stacktrace.length; i++) {
StackTraceElement ste = stacktrace[i];
threadDump.append(INDENT + "at " + ste.toString());
threadDump.append("\n");
for (int j = 1; j < monitors.length; j++) {
MonitorInfo mi = monitors[j];
if (mi.getLockedStackDepth() == i) {
threadDump.append(INDENT + " - locked " + mi);
threadDump.append("\n");
}
}
}
threadDump.append("\n");
}
private static void printLockInfo(LockInfo[] locks, StringBuilder threadDump) {
threadDump.append(INDENT + "Locked synchronizers: count = " + locks.length);
threadDump.append("\n");
for (LockInfo li : locks) {
threadDump.append(INDENT + " - " + li);
threadDump.append("\n");
}
threadDump.append("\n");
}
private static void printThread(ThreadInfo threadInfo, StringBuilder threadDump) {
StringBuilder sb =
new StringBuilder(
"\""
+ threadInfo.getThreadName()
+ "\""
+ " nid="
+ threadInfo.getThreadId()
+ " state="
+ threadInfo.getThreadState());
if (threadInfo.getLockName() != null && threadInfo.getThreadState() != Thread.State.BLOCKED) {
String[] lockInfo = threadInfo.getLockName().split("@");
sb.append("\n" + INDENT + "- waiting on <0x" + lockInfo[1] + "> (a " + lockInfo[0] + ")");
sb.append("\n" + INDENT + "- locked <0x" + lockInfo[1] + "> (a " + lockInfo[0] + ")");
} else if (threadInfo.getLockName() != null
&& threadInfo.getThreadState() == Thread.State.BLOCKED) {
String[] lockInfo = threadInfo.getLockName().split("@");
sb.append(
"\n" + INDENT + "- waiting to lock <0x" + lockInfo[1] + "> (a " + lockInfo[0] + ")");
}
if (threadInfo.isSuspended()) sb.append(" (suspended)");
if (threadInfo.isInNative()) sb.append(" (running in native)");
threadDump.append(sb.toString());
threadDump.append("\n");
if (threadInfo.getLockOwnerName() != null) {
threadDump.append(
INDENT
+ " owned by "
+ threadInfo.getLockOwnerName()
+ " id="
+ threadInfo.getLockOwnerId());
threadDump.append("\n");
}
}
public static CacheException rewrapAsCacheException(Throwable t) {
if (t instanceof CacheException) return (CacheException) t;
else return new CacheException(t);
}
public static <T> Set<T> asSet(T... a) {
if (a.length > 1) return new HashSet<T>(Arrays.<T>asList(a));
else return Collections.singleton(a[0]);
}
/**
* Prints the identity hash code of the object passed as parameter in an hexadecimal format in
* order to safe space.
*/
public static String hexIdHashCode(Object o) {
return Integer.toHexString(System.identityHashCode(o));
}
static final String HEX_VALUES = "0123456789ABCDEF";
public static String hexDump(byte[] buffer) {
StringBuilder buf = new StringBuilder(buffer.length << 1);
for (byte b : buffer) addHexByte(buf, b);
return buf.toString();
}
public static String hexDump(ByteBuffer buffer) {
byte[] data = new byte[buffer.remaining()];
int pos = buffer.position();
buffer.get(data);
buffer.position(pos);
StringBuilder buf = new StringBuilder(buffer.remaining() + 22);
for (byte b : data) addHexByte(buf, b);
return buf.toString();
}
private static void addHexByte(StringBuilder buf, byte b) {
buf.append(HEX_VALUES.charAt((b & 0xF0) >> 4)).append(HEX_VALUES.charAt((b & 0x0F)));
}
public static Double constructDouble(Class<?> type, Object o) {
if (type.equals(Long.class) || type.equals(long.class)) return Double.valueOf((Long) o);
else if (type.equals(Double.class) || type.equals(double.class)) return (Double) o;
else if (type.equals(Integer.class) || type.equals(int.class))
return Double.valueOf((Integer) o);
else if (type.equals(String.class)) return Double.valueOf((String) o);
throw new IllegalStateException(
String.format(
"Expected a value that can be converted into a double: type=%s, value=%s", type, o));
}
/**
* Applies the given hash function to the hash code of a given object, and then normalizes it to
* ensure a positive value is always returned.
*
* @param object to hash
* @param hashFct hash function to apply
* @return a non-null, non-negative normalized hash code for a given object
*/
public static int getNormalizedHash(Object object, Hash hashFct) {
// make sure no negative numbers are involved.
return hashFct.hash(object) & Integer.MAX_VALUE;
}
/**
* Returns the size of each segment, given a number of segments.
*
* @param numSegments number of segments required
* @return the size of each segment
*/
public static int getSegmentSize(int numSegments) {
return (int) Math.ceil((double) (1L << 31) / numSegments);
}
public static boolean isIBMJavaVendor() {
return javaVendor.toLowerCase().contains("ibm");
}
public static String join(List<String> strings, String separator) {
StringBuilder sb = new StringBuilder();
boolean first = true;
for (String string : strings) {
if (!first) {
sb.append(separator);
} else {
first = false;
}
sb.append(string);
}
return sb.toString();
}
/**
* Returns a number such that the number is a power of two that is equal to, or greater than, the
* number passed in as an argument. The smallest number returned will be 1, not 0.
*/
public static int findNextHighestPowerOfTwo(int num) {
if (num <= 0) return 1;
int highestBit = Integer.highestOneBit(num);
return num <= highestBit ? highestBit : highestBit << 1;
}
/**
* A function that calculates hash code of a byte array based on its contents but using the given
* size parameter as deliminator for the content.
*/
public static int hashCode(byte[] bytes, int size) {
int contentLimit = size;
if (size > bytes.length) contentLimit = bytes.length;
int hashCode = 1;
for (int i = 0; i < contentLimit; i++) hashCode = 31 * hashCode + bytes[i];
return hashCode;
}
/**
* Prints {@link Subject}'s principals as a one-liner (as opposed to default Subject's <code>
* toString()</code> method, which prints every principal on separate line).
*/
public static String prettyPrintSubject(Subject subject) {
return (subject == null)
? "null"
: "Subject with principal(s): " + toStr(subject.getPrincipals());
}
}
