/*
* 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 org.apache.openejb.arquillian.common;
import org.apache.openejb.OpenEJBRuntimeException;
import org.apache.openejb.util.DaemonThreadFactory;
import org.jboss.arquillian.container.spi.client.container.DeployableContainer;
import org.jboss.arquillian.container.spi.client.container.DeploymentException;
import org.jboss.shrinkwrap.api.Archive;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Properties;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Level;
import java.util.logging.Logger;
public final class ArquillianUtil {
private static final String OPENEJB_ADAPTER_SYSTEM_PROP = "openejb.arquillian.adapter";
private static final String TOMEE_ADAPTER_SYSTEM_PROP = "tomee.arquillian.adapter";
public static final String PREDEPLOYING_KEY = "openejb.arquillian.predeploy-archives";
private ArquillianUtil() {
// no-op
}
public static boolean isCurrentAdapter(final String name) {
String adapter = System.getProperty(OPENEJB_ADAPTER_SYSTEM_PROP);
if (adapter == null) {
adapter = System.getProperty(TOMEE_ADAPTER_SYSTEM_PROP);
}
return adapter == null || name.equals(adapter);
}
public static Collection<Archive<?>> toDeploy(final Properties properties) {
final Collection<Archive<?>> list = new ArrayList<Archive<?>>();
if (properties.containsKey(ArquillianUtil.PREDEPLOYING_KEY)) {
final String toSplit = properties.getProperty(PREDEPLOYING_KEY).trim();
final ClassLoader loader = Thread.currentThread().getContextClassLoader();
for (final String name : toSplit.split(",")) {
final int bracket = name.indexOf(".[");
if (bracket >= 0) {
final int end = name.indexOf("]");
if (end > bracket) {
final String pkg = name.substring(0, bracket + 1);
final String classes = name.substring(bracket + 2, end);
for (final String n : classes.split("\\|")) {
addClass(list, loader, pkg + n);
}
continue;
}
}
addClass(list, loader, name);
}
}
return list;
}
private static void addClass(final Collection<Archive<?>> list, final ClassLoader loader, final String classname) {
final String name = classname.trim();
try {
final Class<?> clazz = loader.loadClass(name);
for (final Method m : clazz.getMethods()) {
final int modifiers = m.getModifiers();
if (Object.class.equals(m.getDeclaringClass()) || !Archive.class.isAssignableFrom(m.getReturnType())
|| !Modifier.isStatic(modifiers) || !Modifier.isPublic(modifiers)) {
continue;
}
for (final Annotation a : m.getAnnotations()) {
if ("org.jboss.arquillian.container.test.api.Deployment".equals(a.annotationType().getName())) {
final Archive<?> archive = (Archive<?>) m.invoke(null);
list.add(archive);
break;
}
}
}
} catch (final Exception e) {
throw new OpenEJBRuntimeException(e);
}
}
public static void undeploy(final DeployableContainer<?> container, final Collection<Archive<?>> containerArchives) {
if (containerArchives != null) {
for (final Archive<?> a : containerArchives) {
try {
container.undeploy(a);
} catch (final DeploymentException e) {
Logger.getLogger(container.getClass().getName()).log(Level.SEVERE, e.getMessage(), e);
}
}
}
}
public static void preLoadClassesAsynchronously(final String classesToLoad) {
if (classesToLoad == null || classesToLoad.isEmpty()) {
return;
}
final ClassLoader loader = Thread.currentThread().getContextClassLoader();
final String[] split = classesToLoad.trim().split(",");
final ExecutorService es = Executors.newCachedThreadPool(new DaemonThreadFactory(split));
for (final String clazz : split) {
es.submit(new PreLoadClassTask(loader, clazz));
}
es.shutdown();
}
private static class PreLoadClassTask implements Runnable {
private final String clazz;
private final ClassLoader loader;
public PreLoadClassTask(final ClassLoader loader, final String name) {
this.loader = loader;
this.clazz = name;
}
@Override
public void run() {
try {
Class.forName(clazz, true, loader);
} catch (final Throwable th) {
// no-op
}
}
}
}