/**
* Version-dependent support for generating a dummy disk store from the given cache and disk store
* configuration.
*/
protected static void generateDummyDiskStore(
Cache dummyCache, String diskStoreConfig, String fn, Map XmlDiskStoreConfigs) {
DiskStoreDescription dsd = DiskStoreHelper.getDiskStoreDescription(diskStoreConfig);
DiskStoreFactory dummyFactory = ((CacheCreation) dummyCache).createDiskStoreFactory();
dsd.configure(dummyFactory);
String diskStoreName = dsd.getName();
DiskStore dummyDiskStore = null;
try {
dummyDiskStore = dummyFactory.create(diskStoreName);
} catch (IllegalStateException e) {
String msg = "A disk store named \"" + diskStoreName + "\" already exists.";
if (e.getMessage().equals(msg)) {
if (!XmlDiskStoreConfigs.values().contains(diskStoreConfig)) {
String s =
"DiskStore with configuration "
+ diskStoreConfig
+ " named "
+ diskStoreName
+ " was already created without CacheHelper XML using"
+ " an unknown, and possibly different, configuration";
throw new HydraRuntimeException(s);
} // else the configuration was done here, which is fine
} else {
throw e;
}
}
if (Log.getLogWriter().infoEnabled()) {
Log.getLogWriter()
.info("Added dummy disk store: " + DiskStoreHelper.diskStoreToString(dummyDiskStore));
}
// save the disk store config for future reference
XmlDiskStoreConfigs.put(fn, diskStoreConfig);
}
/**
* Version-dependent support for configuring a cache factory from the the given cache
* configuration and distributed system.
*/
protected static Cache configureAndCreateCache(
String cacheConfig, CacheDescription cd, DistributedSystem ds) {
// configure the cache factory
CacheFactory f = new CacheFactory();
Log.getLogWriter().info("Configuring cache factory from config: " + cacheConfig);
cd.configure(f);
// create the cache
Log.getLogWriter().info("Creating cache");
return f.create();
}
/**
* Version-dependent support for generating a dummy gateway sender from the given cache and
* gateway sender configuration.
*/
protected static void generateDummyGatewaySender(
Cache dummyCache, String gatewaySenderConfig, String fn, Map XmlGatewaySenderConfigs) {
String localds = DistributedSystemHelper.getDistributedSystemName();
GatewaySenderDescription gsd =
GatewaySenderHelper.getGatewaySenderDescription(gatewaySenderConfig);
Set<String> remoteDistributedSystems = gsd.getRemoteDistributedSystems();
if (remoteDistributedSystems.size() > 0) {
GatewaySenderFactory dummyFactory = ((CacheCreation) dummyCache).createGatewaySenderFactory();
gsd.configure(dummyFactory);
for (String remoteds : remoteDistributedSystems) {
String id = gsd.getName() + "_" + localds + "_to_" + remoteds;
int remoteid = DistributedSystemHelper.getDistributedSystemId(remoteds);
GatewaySender dummyGatewaySender = null;
try {
dummyGatewaySender = dummyFactory.create(id, remoteid);
GatewaySenderHelper.saveGatewaySenderId(gsd.getName(), gsd.getParallel(), id);
} catch (IllegalStateException e) {
String msg = "A gateway sender named \"" + id + "\" already exists.";
if (e.getMessage().equals(msg)) {
if (!XmlGatewaySenderConfigs.values().contains(gatewaySenderConfig)) {
String s =
"GatewaySender with configuration "
+ gatewaySenderConfig
+ " named "
+ id
+ " was already created without CacheHelper XML using"
+ " an unknown, and possibly different, configuration";
throw new HydraRuntimeException(s);
} // else the configuration was done here, which is fine
} else {
throw e;
}
}
if (Log.getLogWriter().infoEnabled()) {
Log.getLogWriter()
.info(
"Added dummy gateway sender: "
+ GatewaySenderHelper.gatewaySenderToString(dummyGatewaySender));
}
}
// save the gateway sender config for future reference
XmlGatewaySenderConfigs.put(fn, gatewaySenderConfig);
} else {
Log.getLogWriter().info("No remote distributed systems found");
}
}
/**
* Version-dependent support for generating a dummy async event queue from the given cache and
* async event queue configuration.
*/
protected static void generateDummyAsyncEventQueue(
Cache dummyCache, String asyncEventQueueConfig, String fn, Map XmlAsyncEventQueueConfigs) {
AsyncEventQueueDescription aeqd =
AsyncEventQueueHelper.getAsyncEventQueueDescription(asyncEventQueueConfig);
Log.getLogWriter().info("Creating dummy async event queue for " + aeqd.getName());
AsyncEventQueueFactory dummyFactory =
((CacheCreation) dummyCache).createAsyncEventQueueFactory();
aeqd.configure(dummyFactory);
AsyncEventQueue dummyAsyncEventQueue =
dummyFactory.create(aeqd.getName(), aeqd.getAsyncEventListenerInstance());
if (Log.getLogWriter().infoEnabled()) {
Log.getLogWriter()
.info(
"Added dummy async event queue: "
+ AsyncEventQueueHelper.asyncEventQueueToString(dummyAsyncEventQueue));
}
// save the async event queue config for future reference
XmlAsyncEventQueueConfigs.put(fn, asyncEventQueueConfig);
}
/**
* Version-dependent support for generating a dummy gateway receiver from the given cache and
* gateway receiver configuration.
*/
protected static void generateDummyGatewayReceiver(
Cache dummyCache, String gatewayReceiverConfig, String fn, Map XmlGatewayReceiverConfigs) {
GatewayReceiverDescription grd =
GatewayReceiverHelper.getGatewayReceiverDescription(gatewayReceiverConfig);
int numInstances = grd.getNumInstances();
Log.getLogWriter()
.info("Creating " + numInstances + " dummy gateway receivers for " + grd.getName());
GatewayReceiverFactory dummyFactory =
((CacheCreation) dummyCache).createGatewayReceiverFactory();
grd.configure(dummyFactory);
for (int i = 0; i < numInstances; i++) {
GatewayReceiver dummyGatewayReceiver = dummyFactory.create();
if (Log.getLogWriter().infoEnabled()) {
Log.getLogWriter()
.info(
"Added dummy gateway receiver: "
+ GatewayReceiverHelper.gatewayReceiverToString(dummyGatewayReceiver));
}
}
// save the gateway receiver config for future reference
XmlGatewayReceiverConfigs.put(fn, gatewayReceiverConfig);
}
/** Provides support for async event queues running in hydra-managed client VMs. */
public class AsyncEventQueueHelper {
private static LogWriter log = Log.getLogWriter();
// ------------------------------------------------------------------------------
// AsyncEventQueue
// ------------------------------------------------------------------------------
/**
* Creates and starts an async event queue in the current cache. The queue is configured using the
* {@link AsyncEventQueueDescription} corresponding to the given configuration from {@link
* AsyncEventQueuePrms#names}. The id for the queue is the same as the queue configuration name.
*
* <p>This method is thread-safe. The async event queues for a given logical queue configuration
* will only be created once.
*
* @throws HydraRuntimeException if an attempt is made to reconfigure an existing async event
* queue.
*/
public static synchronized AsyncEventQueue createAndStartAsyncEventQueue(
String asyncEventQueueConfig) {
AsyncEventQueue queue = getAsyncEventQueue(asyncEventQueueConfig);
if (queue == null) {
// get the cache
Cache cache = CacheHelper.getCache();
if (cache == null) {
String s = "Cache has not been created yet";
throw new HydraRuntimeException(s);
}
// look up the async event queue configuration
AsyncEventQueueDescription aeqd = getAsyncEventQueueDescription(asyncEventQueueConfig);
// create the disk store
DiskStoreHelper.createDiskStore(aeqd.getDiskStoreDescription().getName());
// create the async event queue
queue = createAsyncEventQueue(aeqd, cache);
}
return queue;
}
private static AsyncEventQueue createAsyncEventQueue(
AsyncEventQueueDescription aeqd, Cache cache) {
// configure the factory
AsyncEventQueueFactory f = cache.createAsyncEventQueueFactory();
log.info("Configuring async event queue factory");
aeqd.configure(f);
log.info("Configured async event queue factory " + f);
// create the async event queue
log.info("Creating and starting async event queue " + aeqd.getName());
AsyncEventQueue queue = f.create(aeqd.getName(), aeqd.getAsyncEventListenerInstance());
log.info("Created and started async event queue: " + asyncEventQueueToString(queue));
return queue;
}
/**
* Returns the async event queues for the current cache, or null if no async event queues or cache
* exists.
*/
public static Set<AsyncEventQueue> getAsyncEventQueues() {
Cache cache = CacheHelper.getCache();
if (cache == null) {
return null;
} else {
Set<AsyncEventQueue> queues = cache.getAsyncEventQueues();
return (queues == null || queues.size() == 0) ? null : queues;
}
}
/**
* Returns the async event queue for the current cache matching the given async event queue id, or
* null if no matching id exists.
*/
public static AsyncEventQueue getAsyncEventQueue(String queueID) {
Set<AsyncEventQueue> queues = getAsyncEventQueues();
if (queues != null) {
for (AsyncEventQueue queue : queues) {
if (queue.getId().equals(queueID)) {
return queue;
}
}
}
return null;
}
/** Returns the given async event queue as a string. */
public static String asyncEventQueueToString(AsyncEventQueue aeq) {
return AsyncEventQueueDescription.asyncEventQueueToString(aeq);
}
// ------------------------------------------------------------------------------
// AsyncEventQueueDescription
// ------------------------------------------------------------------------------
/**
* Returns the {@link AsyncEventQueueDescription} with the given configuration name from {@link
* AsyncEventQueuePrms#names}.
*/
public static AsyncEventQueueDescription getAsyncEventQueueDescription(
String asyncEventQueueConfig) {
if (asyncEventQueueConfig == null) {
throw new IllegalArgumentException("asyncEventQueueConfig cannot be null");
}
log.info("Looking up async event queue config: " + asyncEventQueueConfig);
AsyncEventQueueDescription aeqd =
TestConfig.getInstance().getAsyncEventQueueDescription(asyncEventQueueConfig);
if (aeqd == null) {
String s =
asyncEventQueueConfig + " not found in " + BasePrms.nameForKey(AsyncEventQueuePrms.names);
throw new HydraRuntimeException(s);
}
log.info("Looked up async event queue config:\n" + aeqd);
return aeqd;
}
}
/** Convenience method for reading the list of operations for the current client thread. */
public static OpList getOpList() {
Object key = OpListKey + Thread.currentThread().getName();
OpList opList = (OpList) (AsyncMsgBB.getBB().getSharedMap().get(key));
Log.getLogWriter().info("AsyncBB read from shared map key " + key + ", value " + opList);
return opList;
}
/** Convenience method for writing a list of operations for the current client thread. */
public static void putOpList(OpList opList) {
Object key = OpListKey + Thread.currentThread().getName();
AsyncMsgBB.getBB().getSharedMap().put(key, opList);
Log.getLogWriter().info("AsyncBB put into shared map key " + key + ", value " + opList);
}