/*
* 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.jboss.arquillian.container.spi.client.protocol.metadata.HTTPContext;
import org.jboss.arquillian.container.spi.client.protocol.metadata.ProtocolMetaData;
import org.jboss.arquillian.core.api.Instance;
import org.jboss.arquillian.core.api.InstanceProducer;
import org.jboss.arquillian.core.api.annotation.ApplicationScoped;
import org.jboss.arquillian.core.api.annotation.Inject;
import org.jboss.arquillian.core.api.annotation.Observes;
import org.jboss.arquillian.test.spi.event.enrichment.BeforeEnrichment;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
import java.util.Properties;
import java.util.concurrent.Callable;
public class RemoteInitialContextObserver {
private static final String REMOTE_INITIAL_CONTEXT_FACTORY = "org.apache.openejb.client.RemoteInitialContextFactory";
@Inject
@ApplicationScoped
private InstanceProducer<Context> context;
@Inject
private Instance<Context> existingContext;
@Inject
private Instance<ProtocolMetaData> protocolMetadata;
public void beforeSuite(@Observes final BeforeEnrichment event) {
final ProtocolMetaData metaData = protocolMetadata.get();
if(metaData == null || !metaData.hasContext(HTTPContext.class)) {
return;
}
try {
Thread.currentThread().getContextClassLoader().loadClass(REMOTE_INITIAL_CONTEXT_FACTORY);
final HTTPContext httpContext = metaData.getContexts(HTTPContext.class).iterator().next();
final Properties props = new Properties();
props.setProperty(Context.INITIAL_CONTEXT_FACTORY, REMOTE_INITIAL_CONTEXT_FACTORY);
props.setProperty(Context.PROVIDER_URL, "http://" + httpContext.getHost() + ":" + httpContext.getPort() + "/tomee/ejb");
Context existing = null;
try {
existing = existingContext.get();
} catch (final Throwable t) {
// no-op
}
final Context proxyInstance = (Context) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class<?>[]{Context.class}, new MultipleContextHandler(props, existing));
context.set(new InitialContextWrapper(proxyInstance)); // cause ContextProducer of arquillian supports InitialContext
} catch (final ClassNotFoundException | NamingException e) {
// no-op
}
}
private static class MultipleContextHandler implements InvocationHandler {
private final Context context;
private final Properties properties;
public MultipleContextHandler(final Properties props, final Context initialContexts) {
properties = props;
context = initialContexts;
}
@Override
public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable {
Exception err = null;
for (final Callable<Context> callable : Arrays.asList( // order is important to avoid to start an embedded container for some cases
new Callable<Context>() { // then try to create a remote context
@Override
public Context call() throws Exception {
return new InitialContext(properties);
}
},
new Callable<Context>() { // then existing context
@Override
public Context call() throws Exception {
return context;
}
},
new Callable<Context>() { // then contextual context, this can start an embedded container in some cases
@Override
public Context call() throws Exception {
return new InitialContext();
}
}
)) {
try {
final Context ctx = callable.call();
if (ctx == null) {
continue;
}
return method.invoke(ctx, args);
} catch (final Exception e) {
err = e;
}
}
if (err != null) {
if (InvocationTargetException.class.isInstance(err)) {
throw err.getCause();
}
throw err;
}
return null;
}
}
private static class InitialContextWrapper extends InitialContext {
private final Context delegate;
public InitialContextWrapper(final Context proxyInstance) throws NamingException {
super(true);
this.delegate = proxyInstance;
}
@Override
protected Context getURLOrDefaultInitCtx(final String name) {
return delegate;
}
}
}