public void setAllHasFields(boolean b) {
int hasCounter = 0;
Field thisFields[] = UserSpecifiedRegionAttributes.class.getDeclaredFields();
for (int i = 0; i < thisFields.length; i++) {
if (thisFields[i].getName().startsWith("has")) {
hasCounter++;
try {
thisFields[i].setBoolean(this, b);
} catch (IllegalAccessException ouch) {
Assert.assertTrue(
false, "Could not access field" + thisFields[i].getName() + " on " + getClass());
}
}
}
Assert.assertTrue(hasCounter == HAS_COUNT, "Found " + hasCounter + " methods");
// this.hasCacheListeners = b;
// this.hasCacheLoader = b;
// this.hasCacheWriter = b;
// this.hasConcurrencyLevel = b;
// this.hasDataPolicy = b;
// this.hasDiskDirs = b;
// this.hasDiskWriteAttributes = b;
// this.hasEarlyAck = b;
// this.hasEnableAsyncConflation = b;
// this.hasEnableSubscriptionConflation = b;
// this.hasEnableGateway = b;
// this.hasEntryIdleTimeout = b;
// this.hasEntryTimeToLive = b;
// this.hasEvictionAttributes = b;
// this.hasIgnoreJTA = b;
// this.hasIndexMaintenanceSynchronous = b;
// this.hasInitialCapacity = b;
// this.hasIsLockGrantor = b;
// this.hasKeyConstraint = b;
// this.hasLoadFactor = b;
// this.hasMembershipAttributes = b;
// this.hasMulticastEnabled = b;
// this.hasPartitionAttributes = b;
// this.hasPublisher = b;
// this.hasRegionIdleTimeout = b;
// this.hasRegionTimeToLive = b;
// this.hasScope = b;
// this.hasStatisticsEnabled = b;
// this.hasSubscriptionAttributes = b;
// this.hasValueConstraint = b;
}
/**
* Creates an InetAddress representing the local host. The checked exception <code>
* java.lang.UnknownHostException</code> is captured and results in an Assertion failure instead.
*
* @return InetAddress instance representing the local host
*/
public static InetAddress createLocalHost() {
try {
return SocketCreator.getLocalHost();
} catch (java.net.UnknownHostException e) {
logStackTrace(e);
Assert.assertTrue(false, "Failed to get local host");
return null; // will never happen
}
}
public String getName() {
checkForRmiConnection();
try {
Assert.assertTrue(this.objectName != null);
return (String) this.mbs.getAttribute(this.objectName, "systemName");
} catch (Exception ex) {
String s = "While getting the name";
throw new InternalGemFireException(s, ex);
}
}
public void setAlertLevelAsString(String level) {
checkForRmiConnection();
try {
Assert.assertTrue(this.objectName != null);
this.mbs.setAttribute(this.objectName, new Attribute("alertLevel", level));
} catch (Exception ex) {
String s = "While setting the alert level";
throw new InternalGemFireException(s, ex);
}
}
public void setRemoteCommand(String remoteCommand) {
checkForRmiConnection();
try {
Assert.assertTrue(this.objectName != null);
this.mbs.setAttribute(this.objectName, new Attribute("remoteCommand", remoteCommand));
} catch (Exception ex) {
String s = "While setting the remote command";
throw new InternalGemFireException(s, ex);
}
}
public int getMcastPort() {
checkForRmiConnection();
try {
Assert.assertTrue(this.objectName != null);
Integer value = (Integer) this.mbs.getAttribute(this.objectName, "mcastPort");
return value.intValue();
} catch (Exception ex) {
String s = "While getting the mcastPort";
throw new InternalGemFireException(s, ex);
}
}
/**
* For Externalizable
*
* @see Externalizable
*/
public void writeExternal(ObjectOutput out) throws IOException {
// if (this.transientPort == 0) {
// InternalDistributedSystem.getLoggerI18n().warning(
// LocalizedStrings.DEBUG,
// "externalizing a client ID with zero port: " + this.toString(),
// new Exception("Stack trace"));
// }
Assert.assertTrue(this.identity.length <= BYTES_32KB);
out.writeShort(this.identity.length);
out.write(this.identity);
out.writeInt(this.uniqueId);
}
public void addMembershipListener(SystemMembershipListener listener) {
checkForRmiConnection();
JMXSystemMembershipListener listener2 = new JMXSystemMembershipListener(listener);
try {
Assert.assertTrue(this.objectName != null);
this.mbs.addNotificationListener(
this.objectName, listener2, null /* filter */, null /* handBack */);
} catch (Exception ex) {
String s = "While adding membership listener";
throw new InternalGemFireException(s, ex);
}
}
@Override
public void compile(QCompiler compiler) {
// resolve children type nodes if any, pushing on stack first
// collections are pushed as CollectionTypes, but elementTypes are not yet resolved (set to
// OBJECT_TYPE)
super.compile(compiler);
Assert.assertTrue(this.javaType != null ^ this.typeName != null);
if (this.typeName != null) {
this.javaType = compiler.resolveType(this.typeName);
}
compiler.push(this.javaType);
}
/**
* Converts the string host to an instance of InetAddress. Returns null if the string is empty.
* Fails Assertion if the conversion would result in <code>java.lang.UnknownHostException</code>.
*
* <p>Any leading slashes on host will be ignored.
*
* @param host string version the InetAddress
* @return the host converted to InetAddress instance
*/
public static InetAddress toInetAddress(String host) {
if (host == null || host.length() == 0) {
return null;
}
try {
if (host.indexOf("/") > -1) {
return InetAddress.getByName(host.substring(host.indexOf("/") + 1));
} else {
return InetAddress.getByName(host);
}
} catch (java.net.UnknownHostException e) {
logStackTrace(e);
Assert.assertTrue(false, "Failed to get InetAddress: " + host);
return null; // will never happen since the Assert will fail
}
}
public RemoteOperationMessage(
InternalDistributedMember recipient, String regionPath, ReplyProcessor21 processor) {
Assert.assertTrue(recipient != null, "RemoteMesssage recipient can not be null");
setRecipient(recipient);
this.regionPath = regionPath;
this.processorId = processor == null ? 0 : processor.getProcessorId();
if (processor != null && this.isSevereAlertCompatible()) {
processor.enableSevereAlertProcessing();
}
this.txUniqId = TXManagerImpl.getCurrentTXUniqueId();
TXStateProxy txState = TXManagerImpl.getCurrentTXState();
if (txState != null && txState.isMemberIdForwardingRequired()) {
this.txMemberId = txState.getOriginatingMember();
}
setIfTransactionDistributed();
}
public SystemMember[] getSystemMemberApplications() throws AdminException {
checkForRmiConnection();
try {
ObjectName[] names =
(ObjectName[])
this.mbs.invoke(
this.objectName, "manageSystemMemberApplications", new Object[0], new String[0]);
SystemMember[] members = new SystemMember[names.length];
for (int i = 0; i < names.length; i++) {
Assert.assertTrue(names[i] != null);
members[i] = new JMXSystemMember(this.mbs, names[i]);
}
return members;
} catch (Exception ex) {
String s = "While calling manageSystemMemberApplications";
throw new InternalGemFireException(s, ex);
}
}
/**
* Creates a new <code>JMXDistributedSystem</code> with the given <Code>DistributedSystemConfig
* </code>.
*
* @param config The configuration for connecting to the distributed system
* @param mbs The connection JMX MBean server through which operations are invoked, etc.
* @param agentName The name of the JMX agent MBean
*/
public JMXAdminDistributedSystem(
DistributedSystemConfig config,
MBeanServerConnection mbs,
JMXConnector conn,
final ObjectName agentName) {
super(mbs, null);
try {
this.connector = conn;
this.agentName = agentName;
this.mbs.setAttribute(
agentName, new Attribute("mcastPort", new Integer(config.getMcastPort())));
this.mbs.setAttribute(agentName, new Attribute("mcastAddress", config.getMcastAddress()));
this.mbs.setAttribute(agentName, new Attribute("locators", config.getLocators()));
this.mbs.setAttribute(agentName, new Attribute("bindAddress", config.getBindAddress()));
this.objectName =
(ObjectName) this.mbs.invoke(agentName, "connectToSystem", new Object[0], new String[0]);
Assert.assertTrue(this.objectName != null);
final MBeanServerConnection mbsc = mbs;
WaitCriterion ev =
new WaitCriterion() {
public boolean done() {
try {
return ((Boolean) mbsc.getAttribute(agentName, "connected")).booleanValue();
} catch (Exception e) {
throw new InternalGemFireException("mbean error", e);
}
}
public String description() {
return "agent never connected: " + agentName;
}
};
DistributedTestCase.waitForCriterion(ev, 20 * 1000, 200, true);
} catch (Exception ex) {
String s = "While creating a JMXDistributedSystem";
throw new InternalGemFireException(s, ex);
}
}
public void initHasFields(UserSpecifiedRegionAttributes<K, V> other) {
Field thisFields[] = UserSpecifiedRegionAttributes.class.getDeclaredFields();
Object[] emptyArgs = new Object[] {};
int hasCounter = 0;
String fieldName = null;
for (int i = 0; i < thisFields.length; i++) {
fieldName = thisFields[i].getName();
if (fieldName.startsWith("has")) {
hasCounter++;
boolean bval = false;
try {
Method otherMeth = other.getClass().getMethod(fieldName /*, (Class[])null*/);
bval = ((Boolean) otherMeth.invoke(other, emptyArgs)).booleanValue();
} catch (NoSuchMethodException darnit) {
Assert.assertTrue(false, "A has* method accessor is required for field " + fieldName);
} catch (IllegalAccessException boom) {
Assert.assertTrue(false, "Could not access method " + fieldName + " on " + getClass());
} catch (IllegalArgumentException e) {
Assert.assertTrue(
false, "Illegal argument trying to set field " + e.getLocalizedMessage());
} catch (InvocationTargetException e) {
Assert.assertTrue(false, "Failed trying to invoke method " + e.getLocalizedMessage());
}
try {
thisFields[i].setBoolean(this, bval);
} catch (IllegalAccessException ouch) {
Assert.assertTrue(false, "Could not access field" + fieldName + " on " + getClass());
}
}
}
Assert.assertTrue(
hasCounter == HAS_COUNT,
"Expected " + HAS_COUNT + " methods, got " + hasCounter + " last field: " + fieldName);
// this.hasCacheListeners = other.hasCacheListeners();
// this.hasCacheLoader = other.hasCacheLoader();
// this.hasCacheWriter = other.hasCacheWriter();
// this.hasConcurrencyLevel = other.hasConcurrencyLevel();
// this.hasDataPolicy = other.hasDataPolicy();
// this.hasDiskDirs = other.hasDiskDirs();
// this.hasDiskWriteAttributes = other.hasDiskWriteAttributes();
// this.hasEarlyAck = other.hasEarlyAck();
// this.hasEnableAsyncConflation = other.hasEnableAsyncConflation();
// this.hasEnableSubscriptionConflation = other.hasEnableSubscriptionConflation();
// this.hasEnableGateway = other.hasEnableGateway();
// this.hasEntryIdleTimeout = other.hasEntryIdleTimeout();
// this.hasEntryTimeToLive = other.hasEntryTimeToLive();
// this.hasEvictionAttributes = other.hasEvictionAttributes();
// this.hasIgnoreJTA = other.hasIgnoreJTA();
// this.hasIndexMaintenanceSynchronous = other.hasIndexMaintenanceSynchronous();
// this.hasInitialCapacity = other.hasInitialCapacity();
// this.hasIsLockGrantor = other.hasIsLockGrantor();
// this.hasKeyConstraint = other.hasKeyConstraint();
// this.hasLoadFactor = other.hasLoadFactor();
// this.hasMembershipAttributes = other.hasMembershipAttributes();
// this.hasMulticastEnabled = other.hasMulticastEnabled();
// this.hasPartitionAttributes = other.hasPartitionAttributes();
// this.hasPublisher = other.hasPublisher();
// this.hasRegionIdleTimeout = other.hasRegionIdleTimeout();
// this.hasRegionTimeToLive = other.hasRegionTimeToLive();
// this.hasScope = other.hasScope();
// this.hasStatisticsEnabled = other.hasStatisticsEnabled();
// this.hasSubscriptionAttributes = other.hasSubscriptionAttributes();
// this.hasValueConstraint = other.hasValueConstraint();
}
public static void isTrue(boolean b, String message) {
com.gemstone.gemfire.internal.Assert.assertTrue(b, message);
}
public DistributedSystemConfig getConfig() {
checkForRmiConnection();
Assert.assertTrue(this.objectName != null);
return new JMXDistributedSystemConfig(this.mbs, this.objectName, this.agentName);
}
/** Creates a new <code>JXMDistributedSystem</code> with the given configuration. */
public JMXAdminDistributedSystem(
final String mcastAddress,
final int mcastPort,
final String locators,
final String bindAddress,
final String remoteCommand,
MBeanServerConnection mbs,
JMXConnector conn,
ObjectName agentName) {
this(
new DistributedSystemConfig() {
public String getMcastAddress() {
return mcastAddress;
}
public void setMcastAddress(String mcastAddress) {
throw new UnsupportedOperationException();
}
public int getMcastPort() {
return mcastPort;
}
public void setMcastPort(int mcastPort) {
throw new UnsupportedOperationException();
}
public void setEnableNetworkPartitionDetection(boolean newValue) {
throw new UnsupportedOperationException();
}
public boolean getEnableNetworkPartitionDetection() {
throw new UnsupportedOperationException();
}
public int getMemberTimeout() {
throw new UnsupportedOperationException();
}
public void setMemberTimeout(int value) {
throw new UnsupportedOperationException();
}
public boolean getDisableAutoReconnect() {
throw new UnsupportedOperationException();
}
public void setDisableAutoReconnect(boolean value) {
throw new UnsupportedOperationException();
}
// public int getMcastTtl() {
// throw new UnsupportedOperationException();
// }
// public void setMcastTtl(int v) {
// throw new UnsupportedOperationException();
// }
// public int getSocketLeaseTime() {
// throw new UnsupportedOperationException();
// }
// public void setSocketLeaseTime(int v) {
// throw new UnsupportedOperationException();
// }
// public int getSocketBufferSize() {
// throw new UnsupportedOperationException();
// }
// public void setSocketBufferSize(int v) {
// throw new UnsupportedOperationException();
// }
// public boolean getConserveSockets() {
// throw new UnsupportedOperationException();
// }
// public void setConserveSockets(boolean v) {
// throw new UnsupportedOperationException();
// }
public String getLocators() {
return locators;
}
public void setBindAddress(String bindAddress) {
throw new UnsupportedOperationException();
}
public String getBindAddress() {
return bindAddress;
}
public void setServerBindAddress(String bindAddress) {
throw new UnsupportedOperationException();
}
public String getServerBindAddress() {
throw new UnsupportedOperationException();
}
public void setLocators(String locators) {
throw new UnsupportedOperationException();
}
public String getRemoteCommand() {
return remoteCommand;
}
public void setRemoteCommand(String cmd) {
throw new UnsupportedOperationException();
}
public CacheServerConfig[] getCacheServerConfigs() {
throw new UnsupportedOperationException();
}
public CacheServerConfig createCacheServerConfig() {
throw new UnsupportedOperationException();
}
public void removeCacheServerConfig(CacheServerConfig managerConfig) {
throw new UnsupportedOperationException();
}
public CacheVmConfig[] getCacheVmConfigs() {
throw new UnsupportedOperationException();
}
public CacheVmConfig createCacheVmConfig() {
throw new UnsupportedOperationException();
}
public void removeCacheVmConfig(CacheVmConfig managerConfig) {
throw new UnsupportedOperationException();
}
public DistributionLocatorConfig[] getDistributionLocatorConfigs() {
throw new UnsupportedOperationException();
}
public DistributionLocatorConfig createDistributionLocatorConfig() {
throw new UnsupportedOperationException();
}
public void removeDistributionLocatorConfig(DistributionLocatorConfig managerConfig) {
throw new UnsupportedOperationException();
}
public void addListener(ConfigListener listener) {
throw new UnsupportedOperationException();
}
public void removeListener(ConfigListener listener) {
throw new UnsupportedOperationException();
}
public boolean isSSLEnabled() {
return DistributionConfig.DEFAULT_SSL_ENABLED;
}
public void setSSLEnabled(boolean enabled) {
throw new UnsupportedOperationException();
}
public String getSSLProtocols() {
return DistributionConfig.DEFAULT_SSL_PROTOCOLS;
}
public void setSSLProtocols(String protocols) {
throw new UnsupportedOperationException();
}
public String getSSLCiphers() {
return DistributionConfig.DEFAULT_SSL_CIPHERS;
}
public void setSSLCiphers(String ciphers) {
throw new UnsupportedOperationException();
}
public boolean isSSLAuthenticationRequired() {
return DistributionConfig.DEFAULT_SSL_REQUIRE_AUTHENTICATION;
}
public void setSSLAuthenticationRequired(boolean authRequired) {
throw new UnsupportedOperationException();
}
public Properties getSSLProperties() {
return new Properties();
}
public void setSSLProperties(Properties sslProperties) {
throw new UnsupportedOperationException();
}
// public DistributionLocator[] getDistributionLocators() {
// throw new UnsupportedOperationException();
// }
// public void setDistributionLocators(DistributionLocator[] locs) {
// throw new UnsupportedOperationException();
// }
public String getEntityConfigXMLFile() {
throw new UnsupportedOperationException();
}
public void setEntityConfigXMLFile(String xmlFile) {
throw new UnsupportedOperationException();
}
public String getSystemId() {
throw new UnsupportedOperationException();
}
public void setSystemId(String systemId) {
throw new UnsupportedOperationException();
}
public String getSystemName() {
throw new UnsupportedOperationException();
}
public void setSystemName(String systemName) {
throw new UnsupportedOperationException();
}
public void validate() {}
public void addSSLProperty(String key, String value) {
throw new UnsupportedOperationException();
}
public void removeSSLProperty(String key) {
throw new UnsupportedOperationException();
}
public String getLogFile() {
throw new UnsupportedOperationException();
}
public void setLogFile(String logFile) {
throw new UnsupportedOperationException();
}
public String getLogLevel() {
throw new UnsupportedOperationException();
}
public void setLogLevel(String logLevel) {
throw new UnsupportedOperationException();
}
public int getLogDiskSpaceLimit() {
throw new UnsupportedOperationException();
}
public void setLogDiskSpaceLimit(int limit) {
throw new UnsupportedOperationException();
}
public int getLogFileSizeLimit() {
throw new UnsupportedOperationException();
}
public void setLogFileSizeLimit(int limit) {
throw new UnsupportedOperationException();
}
public boolean getDisableTcp() {
throw new UnsupportedOperationException();
}
public void setDisableTcp(boolean flag) {
throw new UnsupportedOperationException();
}
public int getAckWaitThreshold() {
throw new UnsupportedOperationException();
}
public void setAckWaitThreshold(int seconds) {
throw new UnsupportedOperationException();
}
public int getAckSevereAlertThreshold() {
throw new UnsupportedOperationException();
}
public void setAckSevereAlertThreshold(int seconds) {
throw new UnsupportedOperationException();
}
public int getRefreshInterval() {
throw new UnsupportedOperationException();
}
public void setRefreshInterval(int seconds) {
throw new UnsupportedOperationException();
}
public String getMembershipPortRange() {
throw new UnsupportedOperationException();
}
public void setMembershipPortRange(String membershipPortRange) {
throw new UnsupportedOperationException();
}
public Object clone() {
throw new UnsupportedOperationException();
}
public int getTcpPort() {
throw new UnsupportedOperationException();
}
public void setTcpPort(int port) {
throw new UnsupportedOperationException();
}
},
mbs,
conn,
agentName);
Assert.assertTrue(agentName != null);
}
/** Creates a <code>BridgeServerResponse</code> in response to the given request. */
static BridgeServerResponse create(DistributionManager dm, BridgeServerRequest request) {
BridgeServerResponse m = new BridgeServerResponse();
m.setRecipient(request.getSender());
try {
GemFireCacheImpl cache = (GemFireCacheImpl) CacheFactory.getInstanceCloseOk(dm.getSystem());
if (request.getCacheId() != System.identityHashCode(cache)) {
m.bridgeInfo = null;
} else {
int operation = request.getOperation();
switch (operation) {
case BridgeServerRequest.ADD_OPERATION:
{
BridgeServerImpl bridge = (BridgeServerImpl) cache.addBridgeServer();
m.bridgeInfo = new RemoteBridgeServer(bridge);
break;
}
case BridgeServerRequest.INFO_OPERATION:
{
int id = request.getBridgeId();
// Note that since this is only an informational request
// it is not necessary to synchronize on allBridgeServersLock
for (Iterator iter = cache.getBridgeServers().iterator(); iter.hasNext(); ) {
BridgeServerImpl bridge = (BridgeServerImpl) iter.next();
if (System.identityHashCode(bridge) == id) {
m.bridgeInfo = new RemoteBridgeServer(bridge);
break;
} else {
m.bridgeInfo = null;
}
}
break;
}
case BridgeServerRequest.START_OPERATION:
{
RemoteBridgeServer config = request.getBridgeInfo();
for (Iterator iter = cache.getBridgeServers().iterator(); iter.hasNext(); ) {
BridgeServerImpl bridge = (BridgeServerImpl) iter.next();
if (System.identityHashCode(bridge) == config.getId()) {
bridge.configureFrom(config);
bridge.start();
m.bridgeInfo = new RemoteBridgeServer(bridge);
break;
} else {
m.bridgeInfo = null;
}
}
break;
}
case BridgeServerRequest.STOP_OPERATION:
{
RemoteBridgeServer config = request.getBridgeInfo();
for (Iterator iter = cache.getBridgeServers().iterator(); iter.hasNext(); ) {
BridgeServerImpl bridge = (BridgeServerImpl) iter.next();
if (System.identityHashCode(bridge) == config.getId()) {
bridge.stop();
m.bridgeInfo = new RemoteBridgeServer(bridge);
break;
} else {
m.bridgeInfo = null;
}
}
break;
}
default:
Assert.assertTrue(false, "Unknown bridge server operation: " + operation);
}
}
} catch (CancelException ex) {
m.bridgeInfo = null;
} catch (Exception ex) {
m.exception = ex;
m.bridgeInfo = null;
}
return m;
}
public static void notNull(Object object, String message) {
com.gemstone.gemfire.internal.Assert.assertTrue(object != null, message);
}
/**
* @param count the number of times {@link #countDown} must be invoked before threads can pass
* through {@link #await()}
* @throws IllegalArgumentException if {@code count} is negative
*/
public StoppableCountDownLatch(CancelCriterion stopper, int count) {
Assert.assertTrue(stopper != null);
this.latch = new CountDownLatch(count);
this.stopper = stopper;
}