/*
* JBoss, Home of Professional Open Source.
* Copyright 2008, Red Hat Middleware LLC, and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.test.cluster.testutil;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import javax.management.MBeanServerConnection;
import javax.servlet.ServletException;
import org.apache.catalina.Context;
import org.apache.catalina.Manager;
import org.apache.catalina.Pipeline;
import org.apache.catalina.Valve;
import org.apache.catalina.connector.Request;
import org.apache.catalina.connector.Response;
import org.apache.catalina.core.StandardContext;
import org.apache.commons.httpclient.Cookie;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpState;
import org.jboss.cache.Cache;
import org.jboss.cache.CacheSPI;
import org.jboss.cache.config.BuddyReplicationConfig;
import org.jboss.cache.config.CacheLoaderConfig;
import org.jboss.cache.config.Configuration;
import org.jboss.cache.config.CacheLoaderConfig.IndividualCacheLoaderConfig;
import org.jboss.cache.config.Configuration.CacheMode;
import org.jboss.cache.loader.FileCacheLoaderConfig;
import org.jboss.cache.pojo.PojoCache;
import org.jboss.cache.pojo.PojoCacheFactory;
import org.jboss.metadata.javaee.spec.EmptyMetaData;
import org.jboss.metadata.web.jboss.JBossWebMetaData;
import org.jboss.metadata.web.jboss.PassivationConfig;
import org.jboss.metadata.web.jboss.ReplicationConfig;
import org.jboss.metadata.web.jboss.ReplicationGranularity;
import org.jboss.metadata.web.jboss.ReplicationTrigger;
import org.jboss.metadata.web.jboss.SnapshotMode;
import org.jboss.test.cluster.web.CacheHelper;
import org.jboss.test.cluster.web.mocks.MockEngine;
import org.jboss.test.cluster.web.mocks.MockHost;
import org.jboss.test.cluster.web.mocks.MockRequest;
import org.jboss.test.cluster.web.mocks.MockValve;
import org.jboss.test.cluster.web.mocks.RequestHandler;
import org.jboss.test.cluster.web.mocks.RequestHandlerValve;
import org.jboss.web.tomcat.service.session.JBossCacheManager;
import org.jboss.web.tomcat.service.session.distributedcache.impl.DistributedCacheManagerFactoryImpl;
import org.jboss.web.tomcat.service.session.distributedcache.spi.ClusteringNotSupportedException;
import org.jboss.web.tomcat.service.session.distributedcache.spi.DistributedCacheManagerFactoryFactory;
import org.jgroups.Address;
/**
* Utilities for session testing.
*
* @author <a href="mailto://brian.stansberry@jboss.com">Brian Stansberry</a>
* @version $Revision: 100315 $
*/
public class SessionTestUtil
{
private static final String[] STRING_ONLY_TYPES = { String.class.getName() };
private static final String[] STRING_BOOLEAN_TYPES = { String.class.getName(), boolean.class.getName() };
private static final String CONFIG_LOCATION = "cluster/http/jboss-web-test-service.xml";
private static DistributedCacheManagerFactoryImpl distributedManagerFactory;
static
{
try
{
distributedManagerFactory = (DistributedCacheManagerFactoryImpl) DistributedCacheManagerFactoryFactory.getInstance().getDistributedCacheManagerFactory();
}
catch (ClusteringNotSupportedException e)
{
e.printStackTrace();
}
}
public static JBossCacheManager createManager(String warName, int maxInactiveInterval,
boolean local, String passivationDir,
boolean totalReplication, boolean marshalling,
String jvmRoute, Set<PojoCache> allCaches)
{
return createManager(warName, maxInactiveInterval, local, passivationDir,
totalReplication, marshalling, false, jvmRoute, allCaches);
}
public static JBossCacheManager createManager(String warName, int maxInactiveInterval,
boolean local, String passivationDir,
boolean totalReplication, boolean marshalling,
boolean purgeCacheLoader,
String jvmRoute, Set<PojoCache> allCaches)
{
PojoCache cache = createCache(local, passivationDir, totalReplication, marshalling, allCaches);
return createManager(warName, maxInactiveInterval, cache, jvmRoute);
}
public static JBossCacheManager createManager(String warName,
int maxInactiveInterval,
PojoCache cache,
String jvmRoute)
{
if (distributedManagerFactory == null)
throw new IllegalStateException("Failed to initialize distributedManagerFactory");
distributedManagerFactory.setPojoCache(cache);
JBossCacheManager jbcm = new JBossCacheManager(distributedManagerFactory);
jbcm.setSnapshotMode(SnapshotMode.INSTANT);
setupContainer(warName, jvmRoute, jbcm);
// Do this after assigning the manager to the container, or else
// the container's setting will override ours
// Can't just set the container as their config is per minute not per second
jbcm.setMaxInactiveInterval(maxInactiveInterval);
return jbcm;
}
public static PojoCache createCache(boolean local, String passivationDir,
boolean totalReplication, boolean marshalling, Set<PojoCache> allCaches)
{
return createCache(local, passivationDir, totalReplication, marshalling, false, allCaches);
}
public static PojoCache createCache(boolean local, String passivationDir,
boolean totalReplication, boolean marshalling, boolean purgeCacheLoader, Set<PojoCache> allCaches)
{
Configuration cfg = getConfiguration(local, passivationDir, totalReplication, marshalling, purgeCacheLoader);
PojoCache cache = PojoCacheFactory.createCache(cfg, true);
if (allCaches != null)
allCaches.add(cache);
return cache;
}
public static Configuration getConfiguration(boolean local, String passivationDir,
boolean totalReplication, boolean marshalling, boolean purgeCacheLoader)
{
PojoCache temp = PojoCacheFactory.createCache(CONFIG_LOCATION, false);
Configuration config = temp.getCache().getConfiguration();
if (local)
config.setCacheMode(CacheMode.LOCAL);
if (passivationDir == null)
{
config.setCacheLoaderConfig(null);
}
else
{
CacheLoaderConfig clc = config.getCacheLoaderConfig();
FileCacheLoaderConfig fclc = new FileCacheLoaderConfig();
fclc.setProperties(clc.getFirstCacheLoaderConfig().getProperties());
fclc.setLocation(passivationDir);
fclc.setFetchPersistentState(true);
fclc.setPurgeOnStartup(purgeCacheLoader);
ArrayList<IndividualCacheLoaderConfig> iclcs = new ArrayList<IndividualCacheLoaderConfig>();
iclcs.add(fclc);
clc.setIndividualCacheLoaderConfigs(iclcs);
}
BuddyReplicationConfig brc = config.getBuddyReplicationConfig();
brc.setEnabled(!local && !totalReplication);
config.setUseRegionBasedMarshalling(marshalling);
config.setInactiveOnStartup(marshalling);
// No async marshalling or notifications
config.setSerializationExecutorPoolSize(0);
config.setListenerAsyncPoolSize(0);
// Block for commits -- no races between test driver and replication
config.setSyncCommitPhase(true);
config.setSyncRollbackPhase(true);
return config;
}
public static PojoCache getDistributedCacheManagerFactoryPojoCache()
{
return distributedManagerFactory.getPojoCache();
}
@SuppressWarnings("unchecked")
public static Cache<Object, Object> getDistributedCacheManagerFactoryPlainCache()
{
return distributedManagerFactory.getPlainCache();
}
public static void clearDistributedCacheManagerFactory()
{
distributedManagerFactory.clearCaches();
}
public static void setupContainer(String warName, String jvmRoute, Manager mgr)
{
MockEngine engine = new MockEngine();
engine.setJvmRoute(jvmRoute);
MockHost host = new MockHost();
engine.addChild(host);
host.setName("localhost");
StandardContext container = new StandardContext();
container.setName(warName);
host.addChild(container);
container.setManager(mgr);
}
public static JBossWebMetaData createWebMetaData(int maxSessions)
{
return createWebMetaData(ReplicationGranularity.SESSION,
ReplicationTrigger.SET_AND_NON_PRIMITIVE_GET,
maxSessions, false, -1, -1, false, 0);
}
public static JBossWebMetaData createWebMetaData(int maxSessions, boolean passivation,
int maxIdle, int minIdle)
{
return createWebMetaData(ReplicationGranularity.SESSION,
ReplicationTrigger.SET_AND_NON_PRIMITIVE_GET,
maxSessions, passivation, maxIdle, minIdle, false, 60);
}
public static JBossWebMetaData createWebMetaData(ReplicationGranularity granularity,
ReplicationTrigger trigger,boolean batchMode,
int maxUnreplicated)
{
return createWebMetaData(granularity, trigger, -1, false,
-1, -1, batchMode, maxUnreplicated);
}
public static JBossWebMetaData createWebMetaData(ReplicationGranularity granularity,
ReplicationTrigger trigger,
int maxSessions, boolean passivation,
int maxIdle, int minIdle,
boolean batchMode,
int maxUnreplicated)
{
JBossWebMetaData webMetaData = new JBossWebMetaData();
webMetaData.setDistributable(new EmptyMetaData());
webMetaData.setMaxActiveSessions(new Integer(maxSessions));
PassivationConfig pcfg = new PassivationConfig();
pcfg.setUseSessionPassivation(Boolean.valueOf(passivation));
pcfg.setPassivationMaxIdleTime(new Integer(maxIdle));
pcfg.setPassivationMinIdleTime(new Integer(minIdle));
webMetaData.setPassivationConfig(pcfg);
ReplicationConfig repCfg = new ReplicationConfig();
repCfg.setReplicationGranularity(granularity);
repCfg.setReplicationTrigger(trigger);
repCfg.setReplicationFieldBatchMode(Boolean.valueOf(batchMode));
repCfg.setMaxUnreplicatedInterval(Integer.valueOf(maxUnreplicated));
webMetaData.setReplicationConfig(repCfg);
return webMetaData;
}
public static void invokeRequest(Manager manager, RequestHandler handler, String sessionId)
throws ServletException, IOException
{
Valve valve = setupPipeline(manager, handler);
Request request = setupRequest(manager, sessionId);
invokeRequest(valve, request);
}
public static void invokeRequest(Valve pipelineHead, Request request)
throws ServletException, IOException
{
pipelineHead.invoke(request, request.getResponse());
// StandardHostValve calls request.getSession(false) on way out, so we will too
request.getSession(false);
request.recycle();
}
public static Valve setupPipeline(Manager manager, RequestHandler requestHandler)
{
Pipeline pipeline = manager.getContainer().getPipeline();
// Clean out any existing request handler
Valve[] valves = pipeline.getValves();
RequestHandlerValve mockValve = null;
for (Valve valve: valves)
{
if (valve instanceof RequestHandlerValve)
{
mockValve = (RequestHandlerValve) valve;
break;
}
}
if (mockValve == null)
{
mockValve = new RequestHandlerValve(requestHandler);
pipeline.addValve(mockValve);
}
else
{
mockValve.setRequestHandler(requestHandler);
}
return pipeline.getFirst();
}
public static Request setupRequest(Manager manager, String sessionId)
{
MockRequest request = new MockRequest();
request.setRequestedSessionId(sessionId);
request.setContext((Context) manager.getContainer());
Response response = new Response();
request.setResponse(response);
return request;
}
public static void cleanupPipeline(Manager manager)
{
Pipeline pipeline = manager.getContainer().getPipeline();
Valve[] valves = pipeline.getValves();
for (Valve valve: valves)
{
if (valve instanceof MockValve)
{
((MockValve) valve).clear();
}
}
}
public static Object getSessionVersion(MBeanServerConnection adaptor, String sessionFqn) throws Exception
{
return adaptor.invoke(CacheHelper.OBJECT_NAME,
"getSessionVersion",
new Object[] { sessionFqn },
STRING_ONLY_TYPES);
}
public static Object getBuddySessionVersion(MBeanServerConnection adaptor, String sessionFqn) throws Exception
{
return adaptor.invoke(CacheHelper.OBJECT_NAME,
"getBuddySessionVersion",
new Object[] { sessionFqn },
STRING_ONLY_TYPES);
}
public static void setCacheConfigName(MBeanServerConnection adaptor, String cacheConfigName, boolean usePojoCache) throws Exception
{
adaptor.invoke(CacheHelper.OBJECT_NAME,
"setCacheConfigName",
new Object[] { cacheConfigName, Boolean.valueOf(usePojoCache) },
new String[]{ String.class.getName(), boolean.class.getName() });
}
@SuppressWarnings("unchecked")
public static Set<String> getSessionIds(MBeanServerConnection adaptor, String warFqn) throws Exception
{
return (Set<String>) adaptor.invoke(CacheHelper.OBJECT_NAME,
"getSessionIds",
new Object[] { warFqn },
STRING_ONLY_TYPES);
}
@SuppressWarnings("unchecked")
public static Set<String> getSessionIds(MBeanServerConnection adaptor, String warFqn, boolean includeBuddies) throws Exception
{
return (Set<String>) adaptor.invoke(CacheHelper.OBJECT_NAME,
"getSessionIds",
new Object[] { warFqn, Boolean.valueOf(includeBuddies) },
STRING_BOOLEAN_TYPES);
}
public static boolean isBuddyReplication() throws Exception
{
return Boolean.parseBoolean(System.getProperty("jbosstest.cluster.web.cache.br", "false"));
}
public static String getSessionFqn(String contextPath, String sessionId)
{
return "/JSESSION/" + SessionTestUtil.getContextHostPath("localhost", contextPath) + "/" + sessionId;
}
public static String getContextHostPath(String hostname, String contextPath)
{
return contextPath + "_" + hostname;
}
/**
* Loops, continually calling {@link #areCacheViewsComplete(org.jboss.cache.Cache[])}
* until it either returns true or <code>timeout</code> ms have elapsed.
*
* @param caches caches which must all have consistent views
* @param timeout max number of ms to loop
* @throws RuntimeException if <code>timeout</code> ms have elapse without
* all caches having the same number of members.
*/
public static void blockUntilViewsReceived(Cache<?, ?>[] caches, long timeout)
{
long failTime = System.currentTimeMillis() + timeout;
while (System.currentTimeMillis() < failTime)
{
sleepThread(100);
if (areCacheViewsComplete(caches))
{
return;
}
}
throw new RuntimeException("timed out before caches had complete views");
}
/**
* Checks each cache to see if the number of elements in the array
* returned by {@link CacheSPI#getMembers()} matches the size of
* the <code>caches</code> parameter.
*
* @param caches caches that should form a View
* @return <code>true</code> if all caches have
* <code>caches.length</code> members; false otherwise
* @throws IllegalStateException if any of the caches have MORE view
* members than caches.length
*/
public static boolean areCacheViewsComplete(Cache<?, ?>[] caches)
{
return areCacheViewsComplete(caches, true);
}
public static boolean areCacheViewsComplete(Cache<?, ?>[] caches, boolean barfIfTooManyMembers)
{
int memberCount = caches.length;
for (int i = 0; i < memberCount; i++)
{
if (!isCacheViewComplete(caches[i], memberCount, barfIfTooManyMembers))
{
return false;
}
}
return true;
}
public static boolean isCacheViewComplete(Cache<?, ?> c, int memberCount, boolean barfIfTooManyMembers)
{
CacheSPI<?, ?> cache = (CacheSPI<?, ?>) c;
List<Address> members = cache.getMembers();
if (members == null || memberCount > members.size())
{
return false;
}
else if (memberCount < members.size())
{
if (barfIfTooManyMembers)
{
// This is an exceptional condition
StringBuffer sb = new StringBuffer("Cache at address ");
sb.append(cache.getLocalAddress());
sb.append(" had ");
sb.append(members.size());
sb.append(" members; expecting ");
sb.append(memberCount);
sb.append(". Members were (");
for (int j = 0; j < members.size(); j++)
{
if (j > 0)
{
sb.append(", ");
}
sb.append(members.get(j));
}
sb.append(')');
throw new IllegalStateException(sb.toString());
}
else return false;
}
return true;
}
public static Cookie getSessionCookie(HttpClient client)
{
// Get the state for the JSESSIONID
HttpState state = client.getState();
// Get the JSESSIONID so we can reset the host
Cookie[] cookies = state.getCookies();
Cookie sessionID = null;
for(int c = 0; c < cookies.length; c ++)
{
Cookie k = cookies[c];
if( k.getName().equalsIgnoreCase("JSESSIONID") )
sessionID = k;
}
return sessionID;
}
public static void setCookieDomainToThisServer(HttpClient client, String server)
{
// Get the session cookie
Cookie sessionID = getSessionCookie(client);
if (sessionID == null)
throw new IllegalStateException("No session cookie found on " + client);
// Reset the domain so that the cookie will be sent to server1
sessionID.setDomain(server);
client.getState().addCookie(sessionID);
}
/**
* Puts the current thread to sleep for the desired number of ms, suppressing
* any exceptions.
*
* @param sleeptime number of ms to sleep
*/
public static void sleepThread(long sleeptime)
{
try
{
Thread.sleep(sleeptime);
}
catch (InterruptedException ie)
{
}
}
public static Object getAttributeValue(int value)
{
return Integer.valueOf(value);
}
public static void cleanPassivationDir(File root)
{
if (root.exists())
{
if (root.isDirectory())
{
for (File child : root.listFiles())
{
cleanPassivationDir(child);
}
}
if (!root.delete())
{
root.deleteOnExit();
}
}
}
private SessionTestUtil() {}
}