http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/9a2b5d7b/geode-pulse/src/main/java/org/apache/geode/tools/pulse/internal/data/JMXDataUpdater.java ---------------------------------------------------------------------- diff --git a/geode-pulse/src/main/java/org/apache/geode/tools/pulse/internal/data/JMXDataUpdater.java b/geode-pulse/src/main/java/org/apache/geode/tools/pulse/internal/data/JMXDataUpdater.java new file mode 100644 index 0000000..41374d8 --- /dev/null +++ b/geode-pulse/src/main/java/org/apache/geode/tools/pulse/internal/data/JMXDataUpdater.java @@ -0,0 +1,2392 @@ +/* + * + * 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 com.vmware.geode.tools.pulse.internal.data; + +import com.fasterxml.jackson.databind.ObjectMapper; +import com.fasterxml.jackson.databind.node.ObjectNode; +import com.vmware.geode.tools.pulse.internal.controllers.PulseController; +import com.vmware.geode.tools.pulse.internal.data.JmxManagerFinder.JmxManagerInfo; +import com.vmware.geode.tools.pulse.internal.log.PulseLogWriter; +import com.vmware.geode.tools.pulse.internal.util.StringUtils; + +import javax.management.Attribute; +import javax.management.AttributeList; +import javax.management.AttributeNotFoundException; +import javax.management.InstanceNotFoundException; +import javax.management.IntrospectionException; +import javax.management.InvalidAttributeValueException; +import javax.management.MBeanException; +import javax.management.MBeanServerConnection; +import javax.management.MalformedObjectNameException; +import javax.management.Notification; +import javax.management.NotificationListener; +import javax.management.ObjectName; +import javax.management.ReflectionException; +import javax.management.openmbean.CompositeData; +import javax.management.openmbean.TabularData; +import javax.management.remote.JMXConnector; +import javax.management.remote.JMXConnectorFactory; +import javax.management.remote.JMXServiceURL; +import javax.rmi.ssl.SslRMIClientSocketFactory; +import java.io.IOException; +import java.io.PrintWriter; +import java.io.StringWriter; +import java.lang.management.ManagementFactory; +import java.net.Inet4Address; +import java.net.Inet6Address; +import java.net.InetAddress; +import java.net.UnknownHostException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Date; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.ResourceBundle; +import java.util.Set; + +/** + * Class JMXDataUpdater Class used for creating JMX connection and getting all + * the required MBeans + * + * + * @since GemFire version 7.0.Beta 2012-09-23 + */ +public class JMXDataUpdater implements IClusterUpdater, NotificationListener { + + private final PulseLogWriter LOGGER = PulseLogWriter.getLogger(); + private final ResourceBundle resourceBundle = Repository.get() + .getResourceBundle(); + + private JMXConnector conn = null; + private MBeanServerConnection mbs; + private final String serverName; + private final String port; + private final String userName; + private final String userPassword; + private Boolean isAddedNotiListner = false; + private final Cluster cluster; + + // MBean object names + private ObjectName MBEAN_OBJECT_NAME_SYSTEM_DISTRIBUTED; + private ObjectName MBEAN_OBJECT_NAME_REGION_DISTRIBUTED; + private ObjectName MBEAN_OBJECT_NAME_MEMBER; + private ObjectName MBEAN_OBJECT_NAME_MEMBER_MANAGER; + private ObjectName MBEAN_OBJECT_NAME_STATEMENT_DISTRIBUTED; + private ObjectName MBEAN_OBJECT_NAME_TABLE_AGGREGATE; + + private Set<ObjectName> systemMBeans = null; + + private final String opSignature[] = { String.class.getName(), + String.class.getName(), int.class.getName() }; + + private final ObjectMapper mapper = new ObjectMapper(); + + /** + * constructor used for creating JMX connection + */ + public JMXDataUpdater(String server, String port, Cluster cluster) { + this.serverName = server; + this.port = port; + this.userName = cluster.getJmxUserName(); + this.userPassword = cluster.getJmxUserPassword(); + this.cluster = cluster; + + try { + // Initialize MBean object names + this.MBEAN_OBJECT_NAME_SYSTEM_DISTRIBUTED = new ObjectName( + PulseConstants.OBJECT_NAME_SYSTEM_DISTRIBUTED); + this.MBEAN_OBJECT_NAME_REGION_DISTRIBUTED = new ObjectName( + PulseConstants.OBJECT_NAME_REGION_DISTRIBUTED); + this.MBEAN_OBJECT_NAME_MEMBER_MANAGER = new ObjectName( + PulseConstants.OBJECT_NAME_MEMBER_MANAGER); + this.MBEAN_OBJECT_NAME_MEMBER = new ObjectName( + PulseConstants.OBJECT_NAME_MEMBER); + this.MBEAN_OBJECT_NAME_STATEMENT_DISTRIBUTED = new ObjectName( + PulseConstants.OBJECT_NAME_STATEMENT_DISTRIBUTED); + + // For SQLFire + if (PulseConstants.PRODUCT_NAME_SQLFIRE.equalsIgnoreCase(PulseController + .getPulseProductSupport())) { + this.MBEAN_OBJECT_NAME_TABLE_AGGREGATE = new ObjectName( + PulseConstants.OBJECT_NAME_TABLE_AGGREGATE); + } + + } catch (MalformedObjectNameException e) { + if (LOGGER.severeEnabled()) { + LOGGER.severe(e.getMessage(), e); + } + } catch (NullPointerException e) { + if (LOGGER.severeEnabled()) { + LOGGER.severe(e.getMessage(), e); + } + } + + } + + private JmxManagerInfo getManagerInfoFromLocator(Repository repository) { + + try { + String locatorHost = repository.getJmxHost(); + int locatorPort = Integer.parseInt(repository.getJmxPort()); + + if (LOGGER.infoEnabled()) { + LOGGER.info(resourceBundle.getString("LOG_MSG_HOST") + " : " + locatorHost + " & " + + resourceBundle.getString("LOG_MSG_PORT") + " : " + locatorPort); + } + + InetAddress inetAddr = InetAddress.getByName(locatorHost); + + if ((inetAddr instanceof Inet4Address) || (inetAddr instanceof Inet6Address)) { + + if (inetAddr instanceof Inet4Address) { + if (LOGGER.infoEnabled()) { + LOGGER.info(resourceBundle.getString("LOG_MSG_LOCATOR_IPV4_ADDRESS") + " - " + inetAddr.toString()); + } + } else { + if (LOGGER.infoEnabled()) { + LOGGER.info(resourceBundle.getString("LOG_MSG_LOCATOR_IPV6_ADDRESS") + " - " + inetAddr.toString()); + } + } + + JmxManagerInfo jmxManagerInfo = JmxManagerFinder.askLocatorForJmxManager(inetAddr, locatorPort, 15000, + repository.isUseSSLLocator()); + + if (jmxManagerInfo.port == 0) { + if (LOGGER.infoEnabled()) { + LOGGER.info(resourceBundle.getString("LOG_MSG_LOCATOR_COULD_NOT_FIND_MANAGER")); + } + } + return jmxManagerInfo; + } else { + // Locator has Invalid locator Address + if (LOGGER.infoEnabled()) { + LOGGER.info(resourceBundle.getString("LOG_MSG_LOCATOR_BAD_ADDRESS")); + } + cluster.setConnectionErrorMsg(resourceBundle.getString("LOG_MSG_JMX_CONNECTION_BAD_ADDRESS")); + // update message to display on UI + cluster.setConnectionErrorMsg(resourceBundle + .getString("LOG_MSG_JMX_CONNECTION_BAD_ADDRESS")); + return null; + } + } catch (IOException e) { + StringWriter swBuffer = new StringWriter(); + PrintWriter prtWriter = new PrintWriter(swBuffer); + e.printStackTrace(prtWriter); + LOGGER.severe("Exception Details : " + swBuffer.toString() + "\n"); + } + return null; + } + + /** + * Default connection is Pulse which uses configured userName and password + */ + public JMXConnector getJMXConnection() { + return getJMXConnection(true); + } + + /** + * Get connection for given userName and password. This is used for DataBrowser + * queries which has to be fired using credentials provided at pulse login page + */ + public JMXConnector getJMXConnection(final boolean registerURL) { + JMXConnector connection = null; + // Reference to repository + Repository repository = Repository.get(); + try { + + String jmxSerURL = ""; + + if (LOGGER.infoEnabled()) { + LOGGER.info(resourceBundle.getString("LOG_MSG_USE_LOCATOR_VALUE") + ":" + + repository.getJmxUseLocator()); + } + + if (repository.getJmxUseLocator()) { + JmxManagerInfo jmxManagerInfo = getManagerInfoFromLocator(repository); + + if (jmxManagerInfo.port == 0) { + if (LOGGER.infoEnabled()) { + LOGGER.info(resourceBundle + .getString("LOG_MSG_LOCATOR_COULD_NOT_FIND_MANAGER")); + } + } else { + if (LOGGER.infoEnabled()) { + LOGGER.info(resourceBundle + .getString("LOG_MSG_LOCATOR_FOUND_MANAGER") + + " : " + + resourceBundle.getString("LOG_MSG_HOST") + + " : " + + jmxManagerInfo.host + + " & " + + resourceBundle.getString("LOG_MSG_PORT") + + " : " + + jmxManagerInfo.port + + (jmxManagerInfo.ssl ? resourceBundle + .getString("LOG_MSG_WITH_SSL") : resourceBundle + .getString("LOG_MSG_WITHOUT_SSL"))); + } + + jmxSerURL = formJMXServiceURLString(jmxManagerInfo.host, + String.valueOf(jmxManagerInfo.port)); + } + } else { + if (LOGGER.infoEnabled()) { + LOGGER.info(resourceBundle.getString("LOG_MSG_HOST") + " : " + + this.serverName + " & " + + resourceBundle.getString("LOG_MSG_PORT") + " : " + this.port); + } + jmxSerURL = formJMXServiceURLString(this.serverName, this.port); + } + + if (StringUtils.isNotNullNotEmptyNotWhiteSpace(jmxSerURL)) { + JMXServiceURL url = new JMXServiceURL(jmxSerURL); + String[] creds = { this.userName, this.userPassword }; + Map<String, Object> env = new HashMap<String, Object>(); + env.put(JMXConnector.CREDENTIALS, creds); + + if (repository.isUseSSLManager()) { + // use ssl to connect + env.put("com.sun.jndi.rmi.factory.socket", + new SslRMIClientSocketFactory()); + } + LOGGER.info("Connecting to jmxURL : " + jmxSerURL); + connection = JMXConnectorFactory.connect(url, env); + + // Register Pulse URL if not already present in the JMX Manager + if(registerURL) + registerPulseUrlToManager(connection); + } + } catch (Exception e) { + if (e instanceof UnknownHostException) { + cluster.setConnectionErrorMsg(resourceBundle + .getString("LOG_MSG_JMX_CONNECTION_UNKNOWN_HOST")); + } + + StringWriter swBuffer = new StringWriter(); + PrintWriter prtWriter = new PrintWriter(swBuffer); + e.printStackTrace(prtWriter); + LOGGER.severe("Exception Details : " + swBuffer.toString() + "\n"); + if (this.conn != null) { + try { + this.conn.close(); + } catch (Exception e1) { + LOGGER.severe("Error closing JMX connection " + swBuffer.toString() + + "\n"); + } + this.conn = null; + } + } + return connection; + } + + private String formJMXServiceURLString(String host, String port) + throws UnknownHostException { + /* + * String jmxSerURL = "service:jmx:rmi://" + serverName + "/jndi/rmi://" + + * serverName + ":" + port + "/jmxrmi"; + */ + String jmxSerURL = ""; + if (host.equalsIgnoreCase("localhost")) { + // Create jmx service url for 'localhost' + jmxSerURL = "service:jmx:rmi://" + host + "/jndi/rmi://" + host + ":" + + port + "/jmxrmi"; + } else { + InetAddress inetAddr = InetAddress.getByName(host); + if (inetAddr instanceof Inet4Address) { + // Create jmx service url for IPv4 address + jmxSerURL = "service:jmx:rmi://" + host + "/jndi/rmi://" + host + ":" + + port + "/jmxrmi"; + } else if (inetAddr instanceof Inet6Address) { + // Create jmx service url for IPv6 address + jmxSerURL = "service:jmx:rmi://[" + host + "]/jndi/rmi://[" + host + "]:" + + port + "/jmxrmi"; + } + } + + return jmxSerURL; + } + + // Method registers Pulse URL if not already present in the JMX Manager + private void registerPulseUrlToManager(JMXConnector connection) + throws IOException, AttributeNotFoundException, + InstanceNotFoundException, MBeanException, ReflectionException, + MalformedObjectNameException, InvalidAttributeValueException { + if (LOGGER.infoEnabled()) { + LOGGER.info(resourceBundle + .getString("LOG_MSG_REGISTERING_APP_URL_TO_MANAGER")); + } + + // Reference to repository + Repository repository = Repository.get(); + + // Register Pulse URL if not already present in the JMX Manager + if (connection != null) { + MBeanServerConnection mbsc = connection.getMBeanServerConnection(); + + Set<ObjectName> mbeans = mbsc.queryNames( + this.MBEAN_OBJECT_NAME_MEMBER_MANAGER, null); + + for (ObjectName mbeanName : mbeans) { + String presentUrl = (String) mbsc.getAttribute(mbeanName, + PulseConstants.MBEAN_MANAGER_ATTRIBUTE_PULSEURL); + String pulseWebAppUrl = repository.getPulseWebAppUrl(); + if (pulseWebAppUrl != null + && (presentUrl == null || !pulseWebAppUrl.equals(presentUrl))) { + if (LOGGER.fineEnabled()) { + LOGGER.fine(resourceBundle + .getString("LOG_MSG_SETTING_APP_URL_TO_MANAGER")); + } + Attribute pulseUrlAttr = new Attribute( + PulseConstants.MBEAN_MANAGER_ATTRIBUTE_PULSEURL, pulseWebAppUrl); + mbsc.setAttribute(mbeanName, pulseUrlAttr); + } else { + if (LOGGER.fineEnabled()) { + LOGGER.fine(resourceBundle + .getString("LOG_MSG_APP_URL_ALREADY_PRESENT_IN_MANAGER")); + } + } + } + } + } + + private boolean isConnected() { + // Reference to repository + Repository repository = Repository.get(); + if (repository.getIsEmbeddedMode()) { + if (this.mbs == null) { + this.mbs = ManagementFactory.getPlatformMBeanServer(); + cluster.setConnectedFlag(true); + } + } else { + try { + if (this.conn == null) { + cluster.setConnectedFlag(false); + cluster.setConnectionErrorMsg(resourceBundle + .getString("LOG_MSG_JMX_CONNECTION_NOT_FOUND") + + " " + + resourceBundle.getString("LOG_MSG_JMX_GETTING_NEW_CONNECTION")); + if (LOGGER.fineEnabled()) { + LOGGER.fine(resourceBundle + .getString("LOG_MSG_JMX_CONNECTION_NOT_FOUND") + + " " + + resourceBundle.getString("LOG_MSG_JMX_GET_NEW_CONNECTION")); + } + this.conn = getJMXConnection(); + if (this.conn != null) { + this.mbs = this.conn.getMBeanServerConnection(); + cluster.setConnectedFlag(true); + } else { + if (LOGGER.infoEnabled()) { + LOGGER.info(resourceBundle + .getString("LOG_MSG_JMX_CONNECTION_NOT_FOUND")); + } + return false; + } + } else { + if (LOGGER.fineEnabled()) { + LOGGER.fine(resourceBundle + .getString("LOG_MSG_JMX_CONNECTION_IS_AVAILABLE")); + } + cluster.setConnectedFlag(true); + if (this.mbs == null) { + this.mbs = this.conn.getMBeanServerConnection(); + } + } + } catch (Exception e) { + this.mbs = null; + if (this.conn != null) { + try { + this.conn.close(); + } catch (Exception e1) { + LOGGER.severe(e); + } + } + this.conn = null; + return false; + } + } + + return true; + } + + /** + * function used for updating Cluster Data. + */ + @Override + public boolean updateData() { + try { + if (!this.isConnected()) { + return false; + } + + // deleted Members + cluster.getDeletedMembers().clear(); + for (Entry<String, Cluster.Member> memberSet : cluster.getMembersHMap() + .entrySet()) { + cluster.getDeletedMembers().add(memberSet.getKey()); + } + + // Deleted Regions + cluster.getDeletedRegions().clear(); + for (Cluster.Region region : cluster.getClusterRegions().values()) { + cluster.getDeletedRegions().add(region.getFullPath()); + } + + // try { + + // Cluster + this.systemMBeans = this.mbs.queryNames( + this.MBEAN_OBJECT_NAME_SYSTEM_DISTRIBUTED, null); + for (ObjectName sysMBean : this.systemMBeans) { + updateClusterSystem(sysMBean); + } + + // Cluster Regions/Tables + Set<ObjectName> regionMBeans = this.mbs.queryNames( + this.MBEAN_OBJECT_NAME_REGION_DISTRIBUTED, null); + + Set<ObjectName> tableMBeans = this.mbs.queryNames( + this.MBEAN_OBJECT_NAME_TABLE_AGGREGATE, null); + + if (PulseConstants.PRODUCT_NAME_SQLFIRE.equalsIgnoreCase(PulseController + .getPulseProductSupport())) { + // For SQLfire + for (ObjectName tableMBean : tableMBeans) { + String regNameFromTable = StringUtils + .getRegionNameFromTableName(tableMBean.getKeyProperty("table")); + for (ObjectName regionMBean : regionMBeans) { + String regionName = regionMBean.getKeyProperty("name"); + if (regNameFromTable.equals(regionName)) { + updateClusterRegion(regionMBean); + // Increment cluster region count + cluster.setTotalRegionCount(cluster.getTotalRegionCount() + 1); + break; + } + } + } + } else { + // For Gemfire + for (ObjectName regMBean : regionMBeans) { + updateClusterRegion(regMBean); + } + } + + // Remove deleted regions from cluster's regions list + for (Iterator<String> it = cluster.getDeletedRegions().iterator(); it + .hasNext();) { + cluster.removeClusterRegion(it.next()); + } + + // Cluster Members + Set<ObjectName> memberMBeans = this.mbs.queryNames( + this.MBEAN_OBJECT_NAME_MEMBER, null); + for (ObjectName memMBean : memberMBeans) { + String service = memMBean.getKeyProperty(PulseConstants.MBEAN_KEY_PROPERTY_SERVICE); + if(service==null){ + // Cluster Member + updateClusterMember(memMBean); + } + else { + switch (service) { + case PulseConstants.MBEAN_KEY_PROPERTY_SERVICE_VALUE_REGION: + if (PulseConstants.PRODUCT_NAME_SQLFIRE + .equalsIgnoreCase(PulseController.getPulseProductSupport())) { + // For SQLfire + for (ObjectName tableMBean : tableMBeans) { + String regNameFromTable = StringUtils + .getRegionNameFromTableName(tableMBean + .getKeyProperty("table")); + String regionName = memMBean.getKeyProperty("name"); + if (regNameFromTable.equals(regionName)) { + updateMemberRegion(memMBean); + break; + } + } + } else { + // For Gemfire + updateMemberRegion(memMBean); + } + break; + case PulseConstants.MBEAN_KEY_PROPERTY_SERVICE_VALUE_CACHESERVER: + updateMemberClient(memMBean); + break; + case PulseConstants.MBEAN_KEY_PROPERTY_SERVICE_VALUE_GATEWAYRECEIVER: + updateGatewayReceiver(memMBean); + break; + case PulseConstants.MBEAN_KEY_PROPERTY_SERVICE_VALUE_GATEWAYSENDER: + updateGatewaySender(memMBean); + break; + case PulseConstants.MBEAN_KEY_PROPERTY_SERVICE_VALUE_ASYNCEVENTQUEUE: + updateAsyncEventQueue(memMBean); + break; + case PulseConstants.MBEAN_KEY_PROPERTY_SERVICE_VALUE_LOCATOR: + updateClusterMember(memMBean); + break; + } + } + } + + // Cluster Query Statistics + Set<ObjectName> statementObjectNames = this.mbs.queryNames( + this.MBEAN_OBJECT_NAME_STATEMENT_DISTRIBUTED, null); + //LOGGER.info("statementObjectNames = " + statementObjectNames); + for (ObjectName stmtObjectName : statementObjectNames) { + //LOGGER.info("stmtObjectName = " + stmtObjectName); + updateClusterStatement(stmtObjectName); + } + } catch (IOException ioe) { + + // write errors + StringWriter swBuffer = new StringWriter(); + PrintWriter prtWriter = new PrintWriter(swBuffer); + ioe.printStackTrace(prtWriter); + LOGGER.severe("IOException Details : " + swBuffer.toString() + "\n"); + this.mbs = null; + if (this.conn != null) { + try { + this.conn.close(); + } catch (IOException e1) { + LOGGER.severe("Error closing JMX connection " + swBuffer.toString() + + "\n"); + } + } + + return false; + } + + // If there were members deleted, remove them from the membersList & + // physicalToMember. + Iterator<String> iterator = cluster.getDeletedMembers().iterator(); + while (iterator.hasNext()) { + String memberKey = iterator.next(); + if (cluster.getMembersHMap().containsKey(memberKey)) { + Cluster.Member member = cluster.getMembersHMap().get(memberKey); + List<Cluster.Member> memberArrList = cluster.getPhysicalToMember().get( + member.getHost()); + if (memberArrList != null) { + if (memberArrList.contains(member)) { + String host = member.getHost(); + cluster.getPhysicalToMember().get(member.getHost()).remove(member); + + if (cluster.getPhysicalToMember().get(member.getHost()).size() == 0) { + cluster.getPhysicalToMember().remove(host); + } + } + } + cluster.getMembersHMap().remove(memberKey); + } + + } + + return true; + } + + /** + * function used to get attribute values of Cluster System and map them to + * cluster vo + * + * @param mbeanName + * Cluster System MBean + * @throws IOException + * + */ + private void updateClusterSystem(ObjectName mbeanName) throws IOException { + try { + if (!this.isAddedNotiListner) { + this.mbs.addNotificationListener(mbeanName, this, null, new Object()); + this.isAddedNotiListner = true; + } + + if (PulseConstants.PRODUCT_NAME_SQLFIRE.equalsIgnoreCase(PulseController + .getPulseProductSupport())) { + // Reset to zero + cluster.setServerCount(0); + cluster.setTotalRegionCount(0); + } else { + String[] serverCnt = (String[]) (this.mbs.invoke(mbeanName, + PulseConstants.MBEAN_OPERATION_LISTSERVERS, null, null)); + cluster.setServerCount(serverCnt.length); + } + + TabularData table = (TabularData) (this.mbs.invoke(mbeanName, + PulseConstants.MBEAN_OPERATION_VIEWREMOTECLUSTERSTATUS, null, null)); + + Collection<CompositeData> rows = (Collection<CompositeData>) table + .values(); + cluster.getWanInformationObject().clear(); + for (CompositeData row : rows) { + final Object key = row.get("key"); + final Object value = row.get("value"); + cluster.getWanInformationObject().put((String) key, (Boolean) value); + } + + AttributeList attributeList = this.mbs.getAttributes(mbeanName, + PulseConstants.CLUSTER_MBEAN_ATTRIBUTES); + + for (int i = 0; i < attributeList.size(); i++) { + + Attribute attribute = (Attribute) attributeList.get(i); + String name = attribute.getName(); + switch (name){ + case PulseConstants.MBEAN_ATTRIBUTE_MEMBERCOUNT: + cluster.setMemberCount(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_NUMCLIENTS: + cluster.setClientConnectionCount(getIntegerAttribute( + attribute.getValue(), attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_DISTRIBUTEDSYSTEMID: + cluster.setClusterId(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_LOCATORCOUNT: + cluster.setLocatorCount(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_NUMRUNNIGFUNCTION: + try { + cluster.setRunningFunctionCount(getIntegerAttribute( + attribute.getValue(), attribute.getName())); + } catch (Exception e) { + cluster.setRunningFunctionCount(0); + continue; + } + break; + case PulseConstants.MBEAN_ATTRIBUTE_REGISTEREDCQCOUNT: + cluster.setRegisteredCQCount(getLongAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_NUMSUBSCRIPTIONS: + cluster.setSubscriptionCount(getIntegerAttribute( + attribute.getValue(), attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_NUMTXNCOMMITTED: + cluster.setTxnCommittedCount(getIntegerAttribute( + attribute.getValue(), attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_NUMTXNROLLBACK: + cluster.setTxnRollbackCount(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_TOTALHEAPSIZE: + cluster.setTotalHeapSize(getLongAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_USEDHEAPSIZE: + try { + cluster.setUsedHeapSize(getLongAttribute(attribute.getValue(), + attribute.getName())); + } catch (Exception e) { + cluster.setUsedHeapSize((long) 0); + continue; + } + cluster.getMemoryUsageTrend().add(cluster.getUsedHeapSize()); + break; + case PulseConstants.MBEAN_ATTRIBUTE_TOTALREGIONENTRYCOUNT: + cluster.setTotalRegionEntryCount(getLongAttribute( + attribute.getValue(), attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_CURRENTENTRYCOUNT: + cluster.setCurrentQueryCount(getIntegerAttribute( + attribute.getValue(), attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_TOTALDISKUSAGE: + try { + cluster.setTotalBytesOnDisk(getLongAttribute(attribute.getValue(), + attribute.getName())); + } catch (Exception e) { + cluster.setTotalBytesOnDisk((long) 0); + continue; + } + cluster.getTotalBytesOnDiskTrend().add(cluster.getTotalBytesOnDisk()); + break; + case PulseConstants.MBEAN_ATTRIBUTE_DISKWRITESRATE: + cluster.setDiskWritesRate(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + cluster.getThroughoutWritesTrend().add(cluster.getDiskWritesRate()); + break; + case PulseConstants.MBEAN_ATTRIBUTE_AVERAGEWRITES: + try { + cluster.setWritePerSec(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + } catch (Exception e) { + cluster.setWritePerSec(0); + continue; + } + cluster.getWritePerSecTrend().add(cluster.getWritePerSec()); + break; + case PulseConstants.MBEAN_ATTRIBUTE_AVERAGEREADS: + try { + cluster.setReadPerSec(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + } catch (Exception e) { + cluster.setReadPerSec(0); + continue; + } + cluster.getReadPerSecTrend().add(cluster.getReadPerSec()); + break; + case PulseConstants.MBEAN_ATTRIBUTE_QUERYREQUESTRATE: + cluster.setQueriesPerSec(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + cluster.getQueriesPerSecTrend().add(cluster.getQueriesPerSec()); + break; + case PulseConstants.MBEAN_ATTRIBUTE_DISKREADSRATE: + cluster.setDiskReadsRate(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + cluster.getThroughoutReadsTrend().add(cluster.getDiskReadsRate()); + break; + case PulseConstants.MBEAN_ATTRIBUTE_JVMPAUSES: + long trendVal = determineCurrentJVMPauses( + PulseConstants.JVM_PAUSES_TYPE_CLUSTER, "", + getLongAttribute(attribute.getValue(), attribute.getName())); + cluster.setGarbageCollectionCount(trendVal); + cluster.getGarbageCollectionTrend().add( + cluster.getGarbageCollectionCount()); + break; + case PulseConstants.MBEAN_ATTRIBUTE_TOTALREGIONCOUNT: + if (!PulseConstants.PRODUCT_NAME_SQLFIRE + .equalsIgnoreCase(PulseController.getPulseProductSupport())){ + // for Gemfire + cluster.setTotalRegionCount(getIntegerAttribute( + attribute.getValue(), attribute.getName())); + } + break; + } + } + + // SQLFIRE attributes + if (PulseConstants.PRODUCT_NAME_SQLFIRE.equalsIgnoreCase(PulseController + .getPulseProductSupport())) { + + try { // get sqlfire cluster mbean + + ObjectName sfMemberMbeansObjectName = new ObjectName( + PulseConstants.OBJECT_NAME_SF_CLUSTER); + + Set<ObjectName> sfCluserMBeans = this.mbs.queryNames( + sfMemberMbeansObjectName, null); + + for (ObjectName sfCluserMBean : sfCluserMBeans) { + + AttributeList attrList = this.mbs.getAttributes(sfCluserMBean, + PulseConstants.SF_CLUSTER_MBEAN_ATTRIBUTES); + + for (int i = 0; i < attrList.size(); i++) { + + Attribute attribute = (Attribute) attrList.get(i); + + if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_PROCEDURECALLSINPROGRESS)) { + try { + cluster.setRunningFunctionCount(getIntegerAttribute( + attribute.getValue(), attribute.getName())); + } catch (Exception e) { + cluster.setRunningFunctionCount(0); + continue; + } + } else if (attribute + .getName() + .equals( + PulseConstants.MBEAN_ATTRIBUTE_NETWORKSERVERCLIENTCONNECTIONSTATS)) { + // set number of cluster's clients + CompositeData nscConnStats = (CompositeData) attribute + .getValue(); + + cluster.setClientConnectionCount(getLongAttribute(nscConnStats + .get(PulseConstants.COMPOSITE_DATA_KEY_CONNECTIONSACTIVE), + PulseConstants.COMPOSITE_DATA_KEY_CONNECTIONSACTIVE)); + } + } + break; + } + + } catch (MalformedObjectNameException e) { + LOGGER.warning(e); + } catch (NullPointerException e) { + LOGGER.warning(e); + } + + } + + } catch (InstanceNotFoundException infe) { + LOGGER.warning(infe); + } catch (ReflectionException re) { + LOGGER.warning(re); + } catch (MBeanException anfe) { + LOGGER.warning(anfe); + } + } + + /** + * function used to get attribute values of Gateway Receiver and map them to + * GatewayReceiver inner class object + * + * @param mbeanName + * @return GatewayReceiver object + * @throws InstanceNotFoundException + * @throws IntrospectionException + * @throws ReflectionException + * @throws IOException + * @throws AttributeNotFoundException + * @throws MBeanException + * + * + */ + private Cluster.GatewayReceiver initGatewayReceiver(ObjectName mbeanName) + throws InstanceNotFoundException, IntrospectionException, + ReflectionException, IOException, AttributeNotFoundException, + MBeanException { + + Cluster.GatewayReceiver gatewayReceiver = new Cluster.GatewayReceiver(); + + AttributeList attributeList = this.mbs.getAttributes(mbeanName, + PulseConstants.GATEWAY_MBEAN_ATTRIBUTES); + + for (int i = 0; i < attributeList.size(); i++) { + Attribute attribute = (Attribute) attributeList.get(i); + + if (attribute.getName().equals(PulseConstants.MBEAN_ATTRIBUTE_PORT)) { + gatewayReceiver.setListeningPort(getIntegerAttribute( + attribute.getValue(), attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_EVENTRECEIVEDDATE)) { + gatewayReceiver.setLinkThroughput(getDoubleAttribute( + attribute.getValue(), attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_AVEARGEBATCHPROCESSINGTIME)) { + gatewayReceiver.setAvgBatchProcessingTime(getLongAttribute( + attribute.getValue(), attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_RUNNING)) { + gatewayReceiver.setStatus(getBooleanAttribute(attribute.getValue(), + attribute.getName())); + } + } + return gatewayReceiver; + } + + /** + * function used to get attribute values of Gateway Sender and map them to + * GatewaySender inner class object + * + * @param mbeanName + * @return + * @throws InstanceNotFoundException + * @throws IntrospectionException + * @throws ReflectionException + * @throws IOException + * @throws AttributeNotFoundException + * @throws MBeanException + */ + private Cluster.GatewaySender initGatewaySender(ObjectName mbeanName) + throws InstanceNotFoundException, IntrospectionException, + ReflectionException, IOException, AttributeNotFoundException, + MBeanException { + + Cluster.GatewaySender gatewaySender = new Cluster.GatewaySender(); + AttributeList attributeList = this.mbs.getAttributes(mbeanName, + PulseConstants.GATEWAYSENDER_MBEAN_ATTRIBUTES); + + for (int i = 0; i < attributeList.size(); i++) { + Attribute attribute = (Attribute) attributeList.get(i); + String name = attribute.getName(); + switch (name){ + case PulseConstants.MBEAN_ATTRIBUTE_EVENTRECEIVEDDATE: + gatewaySender.setLinkThroughput(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_BATCHSIZE: + gatewaySender.setBatchSize(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_SENDERID: + gatewaySender.setId(getStringAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_EVENTQUEUESIZE: + gatewaySender.setQueueSize(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_RUNNING: + gatewaySender.setStatus(getBooleanAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_PRIMARY: + gatewaySender.setPrimary(getBooleanAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_PERSISTENCEENABLED: + gatewaySender.setPersistenceEnabled(getBooleanAttribute( + attribute.getValue(), attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_PARALLEL: + gatewaySender.setSenderType(getBooleanAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_REMOTE_DS_ID: + gatewaySender.setRemoteDSId(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_EVENTS_EXCEEDING_ALERT_THRESHOLD: + gatewaySender.setEventsExceedingAlertThreshold(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + break; + } + } + return gatewaySender; + } + + /** + * function used for getting list of Gateway Senders from mBean for giving + * member and update the list of gateway senders for respective member object + */ + private void updateGatewaySender(ObjectName mbeanName) throws IOException { + + try { + String memberName = mbeanName + .getKeyProperty(PulseConstants.MBEAN_KEY_PROPERTY_MEMBER); + + if (cluster.getMembersHMap().containsKey(memberName)) { + Cluster.Member existingMember = cluster.getMembersHMap() + .get(memberName); + Cluster.GatewaySender gatewaySender = initGatewaySender(mbeanName); + for (Iterator<Cluster.GatewaySender> it = existingMember + .getGatewaySenderList().iterator(); it.hasNext();) { + Cluster.GatewaySender exisGatewaySender = it.next(); + if ((exisGatewaySender.getId()).equals(gatewaySender.getId())) { + it.remove(); + break; + } + } + + // Add gateway sender + existingMember.getGatewaySenderList().add(gatewaySender); + + } else { + Cluster.Member member = new Cluster.Member(); + member.setName(memberName); + member.setId(memberName); + Cluster.GatewaySender gatewaySender = initGatewaySender(mbeanName); + member.getGatewaySenderList().add(gatewaySender); + cluster.getMembersHMap().put(memberName, member); + } + } catch (InstanceNotFoundException infe) { + LOGGER.warning(infe); + } catch (ReflectionException re) { + LOGGER.warning(re); + } catch (MBeanException me) { + LOGGER.warning(me); + } catch (AttributeNotFoundException anfe) { + LOGGER.warning(anfe); + } catch (IntrospectionException ire) { + LOGGER.warning(ire); + } + } + + /** + * function used to get attribute values of Async Event Queue and map them to + * Async Event Queue inner class object + * + * @param mbeanName + * @return + * @throws InstanceNotFoundException + * @throws IntrospectionException + * @throws ReflectionException + * @throws IOException + * @throws AttributeNotFoundException + * @throws MBeanException + */ + private Cluster.AsyncEventQueue initAsyncEventQueue(ObjectName mbeanName) + throws InstanceNotFoundException, IntrospectionException, + ReflectionException, IOException, AttributeNotFoundException, + MBeanException { + + Cluster.AsyncEventQueue asyncEventQueue = new Cluster.AsyncEventQueue(); + AttributeList attributeList = this.mbs.getAttributes(mbeanName, + PulseConstants.ASYNC_EVENT_QUEUE_MBEAN_ATTRIBUTES); + + for (int i = 0; i < attributeList.size(); i++) { + Attribute attribute = (Attribute) attributeList.get(i); + String name = attribute.getName(); + switch (name){ + case PulseConstants.MBEAN_ATTRIBUTE_AEQ_ASYNCEVENTID: + asyncEventQueue.setId(getStringAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_AEQ_ASYNC_EVENT_LISTENER: + asyncEventQueue.setAsyncEventListener(getStringAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_AEQ_BATCH_CONFLATION_ENABLED: + asyncEventQueue.setBatchConflationEnabled(getBooleanAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_AEQ_BATCH_TIME_INTERVAL: + asyncEventQueue.setBatchTimeInterval(getLongAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_AEQ_BATCH_SIZE: + asyncEventQueue.setBatchSize(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_AEQ_EVENT_QUEUE_SIZE: + asyncEventQueue.setEventQueueSize(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_AEQ_PARALLEL: + asyncEventQueue.setParallel(getBooleanAttribute( + attribute.getValue(), attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_AEQ_PRIMARY: + asyncEventQueue.setPrimary(getBooleanAttribute(attribute.getValue(), + attribute.getName())); + break; + } + } + return asyncEventQueue; + } + + /** + * function used for getting list of Gateway Senders from mBean for giving + * member and update the list of gateway senders for respective member object + */ + private void updateAsyncEventQueue(ObjectName mbeanName) throws IOException { + try { + String memberName = mbeanName + .getKeyProperty(PulseConstants.MBEAN_KEY_PROPERTY_MEMBER); + + if (cluster.getMembersHMap().containsKey(memberName)) { + Cluster.Member existingMember = cluster.getMembersHMap() + .get(memberName); + Cluster.AsyncEventQueue asyncQ = initAsyncEventQueue(mbeanName); + for (Iterator<Cluster.AsyncEventQueue> it = existingMember.getAsyncEventQueueList().iterator(); it.hasNext();) { + Cluster.AsyncEventQueue exisAsyncEventQueue = it.next(); + if ((exisAsyncEventQueue.getId()).equals(asyncQ.getId())) { + it.remove(); + break; + } + } + + // Add async event queue + existingMember.getAsyncEventQueueList().add(asyncQ); + } else { + Cluster.Member member = new Cluster.Member(); + member.setName(memberName); + member.setId(memberName); + + Cluster.AsyncEventQueue asyncQ = initAsyncEventQueue(mbeanName); + member.getAsyncEventQueueList().add(asyncQ); + + cluster.getMembersHMap().put(memberName, member); + } + } catch (InstanceNotFoundException infe) { + LOGGER.warning(infe); + } catch (ReflectionException re) { + LOGGER.warning(re); + } catch (MBeanException me) { + LOGGER.warning(me); + } catch (AttributeNotFoundException anfe) { + LOGGER.warning(anfe); + } catch (IntrospectionException ire) { + LOGGER.warning(ire); + } + } + + /** + * function used for getting a Gateway Receiver from mBean for giving member + * and update the gateway receiver for respective member object + */ + private void updateGatewayReceiver(ObjectName mbeanName) throws IOException { + + try { + String memberName = mbeanName + .getKeyProperty(PulseConstants.MBEAN_KEY_PROPERTY_MEMBER); + + if (cluster.getMembersHMap().containsKey(memberName)) { + Cluster.Member existingMember = cluster.getMembersHMap() + .get(memberName); + Cluster.GatewayReceiver gatewayReceiver = initGatewayReceiver(mbeanName); + existingMember.setGatewayReceiver(gatewayReceiver); + } else { + Cluster.Member member = new Cluster.Member(); + member.setName(memberName); + member.setId(memberName); + Cluster.GatewayReceiver gatewayReceiver = initGatewayReceiver(mbeanName); + member.setGatewayReceiver(gatewayReceiver); + cluster.getMembersHMap().put(memberName, member); + } + } catch (InstanceNotFoundException infe) { + LOGGER.warning(infe); + } catch (ReflectionException re) { + LOGGER.warning(re); + } catch (MBeanException me) { + LOGGER.warning(me); + } catch (AttributeNotFoundException anfe) { + LOGGER.warning(anfe); + } catch (IntrospectionException ire) { + LOGGER.warning(ire); + } + } + + /** + * function used for getting member clients from mbean and update the clients + * information in member object's client arraylist + */ + private void updateMemberClient(ObjectName mbeanName) throws IOException { + + try { + String memberName = mbeanName + .getKeyProperty(PulseConstants.MBEAN_KEY_PROPERTY_MEMBER); + + if (cluster.getMembersHMap().containsKey(memberName)) { + Cluster.Member existingMember = cluster.getMembersHMap() + .get(memberName); + HashMap<String, Cluster.Client> memberClientsHM = new HashMap<String, Cluster.Client>(); + + existingMember.setMemberPort("" + + this.mbs.getAttribute(mbeanName, + PulseConstants.MBEAN_ATTRIBUTE_PORT)); + + this.mbs.getAttribute(mbeanName, PulseConstants.MBEAN_ATTRIBUTE_HOSTNAMEFORCLIENTS_ALT); + existingMember.setHostnameForClients((String)this.mbs.getAttribute(mbeanName, PulseConstants.MBEAN_ATTRIBUTE_HOSTNAMEFORCLIENTS_ALT)); + existingMember.setBindAddress((String)this.mbs.getAttribute(mbeanName, PulseConstants.MBEAN_ATTRIBUTE_BINDADDRESS)); + + CompositeData[] compositeData = (CompositeData[]) (this.mbs.invoke( + mbeanName, PulseConstants.MBEAN_OPERATION_SHOWALLCLIENTS, null, + null)); + for (CompositeData cmd : compositeData) { + Cluster.Client client = new Cluster.Client(); + if (cmd.containsKey(PulseConstants.COMPOSITE_DATA_KEY_CLIENTID)) { + client.setId((String) cmd + .get(PulseConstants.COMPOSITE_DATA_KEY_CLIENTID)); + } + if (cmd.containsKey(PulseConstants.COMPOSITE_DATA_KEY_NAME)) { + client.setName((String) cmd + .get(PulseConstants.COMPOSITE_DATA_KEY_NAME)); + } + if (cmd.containsKey(PulseConstants.COMPOSITE_DATA_KEY_HOSTNAME)) { + client.setHost((String) cmd + .get(PulseConstants.COMPOSITE_DATA_KEY_HOSTNAME)); + } + if (cmd.containsKey(PulseConstants.COMPOSITE_DATA_KEY_QUEUESIZE)) { + client.setQueueSize((Integer) cmd + .get(PulseConstants.COMPOSITE_DATA_KEY_QUEUESIZE)); + } + if (cmd.containsKey(PulseConstants.COMPOSITE_DATA_KEY_PROCESSCPUTIME)) { + client.setProcessCpuTime((Long) cmd + .get(PulseConstants.COMPOSITE_DATA_KEY_PROCESSCPUTIME)); + } + if (cmd.containsKey(PulseConstants.COMPOSITE_DATA_KEY_UPTIME)) { + client.setUptime((Long) cmd + .get(PulseConstants.COMPOSITE_DATA_KEY_UPTIME)); + } + if (cmd.containsKey(PulseConstants.COMPOSITE_DATA_KEY_NUMOFTHREADS)) { + client.setThreads((Integer) cmd + .get(PulseConstants.COMPOSITE_DATA_KEY_NUMOFTHREADS)); + } + if (cmd.containsKey(PulseConstants.COMPOSITE_DATA_KEY_NUMOFGETS)) { + client.setGets((Integer) cmd + .get(PulseConstants.COMPOSITE_DATA_KEY_NUMOFGETS)); + } + if (cmd.containsKey(PulseConstants.COMPOSITE_DATA_KEY_NUMOFPUTS)) { + client.setPuts((Integer) cmd + .get(PulseConstants.COMPOSITE_DATA_KEY_NUMOFPUTS)); + } + if (cmd.containsKey(PulseConstants.COMPOSITE_DATA_KEY_CPUS)) { + client.setCpus((Integer) cmd + .get(PulseConstants.COMPOSITE_DATA_KEY_CPUS)); + } + if (cmd.containsKey(PulseConstants.COMPOSITE_DATA_KEY_CPUS)) { + client.setCpuUsage(0); + } + if (cmd.containsKey(PulseConstants.COMPOSITE_DATA_KEY_CONNECTED)){ + client.setConnected((Boolean) cmd.get(PulseConstants.COMPOSITE_DATA_KEY_CONNECTED)); + } + if (cmd.containsKey(PulseConstants.COMPOSITE_DATA_KEY_CLIENTCQCOUNT)){ + client.setClientCQCount((Integer) cmd.get(PulseConstants.COMPOSITE_DATA_KEY_CLIENTCQCOUNT)); + } + if (cmd.containsKey(PulseConstants.COMPOSITE_DATA_KEY_SUBSCRIPTIONENABLED)){ + client.setSubscriptionEnabled((Boolean) cmd.get(PulseConstants.COMPOSITE_DATA_KEY_SUBSCRIPTIONENABLED)); + } + memberClientsHM.put(client.getId(), client); + } + existingMember.updateMemberClientsHMap(memberClientsHM); + } + } catch (InstanceNotFoundException infe) { + LOGGER.warning(infe); + } catch (ReflectionException re) { + LOGGER.warning(re); + } catch (MBeanException me) { + LOGGER.warning(me); + } catch (AttributeNotFoundException anfe) { + LOGGER.warning(anfe); + } + } + + /** + * Add member specific region information on the region + * + * @param regionObjectName: used to construct the jmx objectname. For region name that has special characters in, it will have double quotes around it. + * @param region + */ + private void updateRegionOnMembers(String regionObjectName, String regionFullPath, Cluster.Region region) throws IOException { + + try{ + List<String> memberNamesTemp = region.getMemberName(); + ArrayList<String> memberNames = new ArrayList<String>(memberNamesTemp); + + List<Cluster.RegionOnMember> regionOnMemberList = new ArrayList<Cluster.RegionOnMember>(); + List<Cluster.RegionOnMember> regionOnMemberListNew = new ArrayList<Cluster.RegionOnMember>(); + Cluster.RegionOnMember[] regionOnMemberNames = region.getRegionOnMembers(); + + if ((regionOnMemberNames != null) && (regionOnMemberNames.length > 0)) { + regionOnMemberList = new ArrayList<Cluster.RegionOnMember>(Arrays.asList(regionOnMemberNames)); + } + LOGGER.fine("updateRegionOnMembers : # regionOnMembers objects in region = " + regionOnMemberList.size()); + + for(Cluster.RegionOnMember anRom : regionOnMemberList) { + + for(String memberName : memberNames){ + if(anRom.getMemberName().equals(memberName)){ + // Add regionOnMember object in new list + regionOnMemberListNew.add(anRom); + + LOGGER.fine("updateRegionOnMembers : Processing existing Member name = " + anRom.getMemberName()); + String objectNameROM = PulseConstants.OBJECT_NAME_REGION_ON_MEMBER_REGION + regionObjectName + PulseConstants.OBJECT_NAME_REGION_ON_MEMBER_MEMBER + anRom.getMemberName(); + ObjectName regionOnMemberMBean = new ObjectName(objectNameROM); + LOGGER.fine("updateRegionOnMembers : Object name = " + regionOnMemberMBean.getCanonicalName()); + + AttributeList attributeList = this.mbs.getAttributes(regionOnMemberMBean, PulseConstants.REGION_ON_MEMBER_MBEAN_ATTRIBUTES); + for (int i = 0; i < attributeList.size(); i++) { + Attribute attribute = (Attribute) attributeList.get(i); + String name = attribute.getName(); + switch(name){ + case PulseConstants.MBEAN_ATTRIBUTE_ENTRYSIZE: + anRom.setEntrySize(getLongAttribute(attribute.getValue(), + attribute.getName())); + LOGGER.fine("updateRegionOnMembers : anRom.getEntrySize() = " + anRom.getEntrySize()); + break; + case PulseConstants.MBEAN_ATTRIBUTE_ENTRYCOUNT: + anRom.setEntryCount(getLongAttribute(attribute.getValue(), + attribute.getName())); + LOGGER.fine("updateRegionOnMembers : anRom.getEntryCount() = " + anRom.getEntryCount()); + break; + case PulseConstants.MBEAN_ATTRIBUTE_PUTSRATE: + anRom.setPutsRate(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + LOGGER.fine("updateRegionOnMembers : anRom.getPutsRate() = " + anRom.getPutsRate()); + break; + case PulseConstants.MBEAN_ATTRIBUTE_GETSRATE: + anRom.setGetsRate(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + LOGGER.fine("updateRegionOnMembers : anRom.getGetsRate() = " + anRom.getGetsRate()); + break; + case PulseConstants.MBEAN_ATTRIBUTE_DISKREADSRATE: + anRom.setDiskGetsRate(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + LOGGER.fine("updateRegionOnMembers : anRom.getDiskGetsRate() = " + anRom.getDiskGetsRate()); + break; + case PulseConstants.MBEAN_ATTRIBUTE_DISKWRITESRATE: + anRom.setDiskPutsRate(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + LOGGER.fine("updateRegionOnMembers : anRom.getDiskPutsRate() = " + anRom.getDiskPutsRate()); + break; + case PulseConstants.MBEAN_ATTRIBUTE_LOCALMAXMEMORY: + anRom.setLocalMaxMemory(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + LOGGER.fine("updateRegionOnMembers : anRom.getLocalMaxMemory() = " + anRom.getLocalMaxMemory()); + break; + } + } + + anRom.getGetsPerSecTrend().add(anRom.getGetsRate()); + anRom.getPutsPerSecTrend().add(anRom.getPutsRate()); + anRom.getDiskReadsPerSecTrend().add(anRom.getDiskGetsRate()); + anRom.getDiskWritesPerSecTrend().add(anRom.getDiskPutsRate()); + LOGGER.fine("updateRegionOnMembers : Existing member on region : getGetsRate() = " + anRom.getGetsPerSecTrend().size() + ", getPutsRate() = " + + anRom.getPutsPerSecTrend().size() + ", getDiskGetsRate() = " + anRom.getDiskReadsPerSecTrend().size() + ", getDiskPutsRate() = " + + anRom.getDiskWritesPerSecTrend().size()); + + //remove existing member names from list so only new ones will remain + memberNames.remove(anRom.getMemberName()); + + break; + } + } + } + + LOGGER.fine("updateRegionOnMembers : Loop over remaining member names and adding new member in region. Existing count = " + regionOnMemberList.size()); + LOGGER.fine("updateRegionOnMembers : Remaining new members in this region = " + memberNames.size()); + //loop over the remaining regions members and add new members for this region + for(String memberName : memberNames) { + String objectNameROM = PulseConstants.OBJECT_NAME_REGION_ON_MEMBER_REGION + regionObjectName + PulseConstants.OBJECT_NAME_REGION_ON_MEMBER_MEMBER + memberName; + ObjectName regionOnMemberMBean = new ObjectName(objectNameROM); + Cluster.RegionOnMember regionOnMember = new Cluster.RegionOnMember(); + regionOnMember.setMemberName(memberName); + regionOnMember.setRegionFullPath(regionFullPath); + AttributeList attributeList = this.mbs.getAttributes(regionOnMemberMBean, PulseConstants.REGION_ON_MEMBER_MBEAN_ATTRIBUTES); + for (int i = 0; i < attributeList.size(); i++) { + Attribute attribute = (Attribute) attributeList.get(i); + String name=attribute.getName(); + switch (name){ + case PulseConstants.MBEAN_ATTRIBUTE_ENTRYSIZE: + regionOnMember.setEntrySize(getLongAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_ENTRYCOUNT: + regionOnMember.setEntryCount(getLongAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_PUTSRATE: + regionOnMember.setPutsRate(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_GETSRATE: + regionOnMember.setGetsRate(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_DISKREADSRATE: + regionOnMember.setDiskGetsRate(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_DISKWRITESRATE: + regionOnMember.setDiskPutsRate(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_LOCALMAXMEMORY: + regionOnMember.setLocalMaxMemory(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + break; + } + } + + regionOnMember.getGetsPerSecTrend().add(regionOnMember.getGetsRate()); + regionOnMember.getPutsPerSecTrend().add(regionOnMember.getPutsRate()); + regionOnMember.getDiskReadsPerSecTrend().add(regionOnMember.getDiskGetsRate()); + regionOnMember.getDiskWritesPerSecTrend().add(regionOnMember.getDiskPutsRate()); + + LOGGER.fine("updateRegionOnMembers : Adding New member on region : getGetsRate() = " + regionOnMember.getGetsRate() + ", getPutsRate() = " + + regionOnMember.getPutsRate() + ", getDiskGetsRate() = " + regionOnMember.getDiskGetsRate() + ", getDiskPutsRate() = " + + regionOnMember.getDiskPutsRate()); + + regionOnMemberListNew.add(regionOnMember); + } + + //set region on member + region.setRegionOnMembers(regionOnMemberListNew); + LOGGER.fine("updateRegionOnMembers : Total regions on member in region " + region.getFullPath() + " after update = " + region.getRegionOnMembers().length); + } catch (MalformedObjectNameException e) { + LOGGER.warning(e); + } catch (InstanceNotFoundException infe) { + LOGGER.warning(infe); + } catch (ReflectionException re) { + LOGGER.warning(re); + } + } + + /** + * function used to get attribute values of Cluster Region and map them to + * cluster region vo + * + * @param mbeanName + * Cluster Region MBean + */ + private void updateClusterRegion(ObjectName mbeanName) throws IOException { + + try { + + AttributeList attributeList = this.mbs.getAttributes(mbeanName, + PulseConstants.REGION_MBEAN_ATTRIBUTES); + + // retrieve the full path of the region + String regionObjectName = mbeanName.getKeyProperty("name"); + String regionFullPath = null; + for (int i = 0; i < attributeList.size(); i++) { + Attribute attribute = (Attribute) attributeList.get(i); + + if (attribute.getName().equals(PulseConstants.MBEAN_ATTRIBUTE_FULLPATH)) { + regionFullPath = getStringAttribute(attribute.getValue(), + attribute.getName()); + break; + } + } + + Cluster.Region region = cluster.getClusterRegions().get(regionFullPath); + + if (null == region) { + region = new Cluster.Region(); + } + + for (int i = 0; i < attributeList.size(); i++) { + + Attribute attribute = (Attribute) attributeList.get(i); + + String name = attribute.getName(); + switch (name){ + case PulseConstants.MBEAN_ATTRIBUTE_MEMBERS: + String memName[] = (String[]) attribute.getValue(); + region.getMemberName().clear(); + for (int k = 0; k < memName.length; k++) { + region.getMemberName().add(memName[k]); + } + break; + case PulseConstants.MBEAN_ATTRIBUTE_FULLPATH: + region.setFullPath(getStringAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_DISKREADSRATE: + region.setDiskReadsRate(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_DISKWRITESRATE: + region.setDiskWritesRate(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_EMPTYNODES: + region.setEmptyNode(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_GETSRATE: + region.setGetsRate(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_LRUEVICTIONRATE: + region.setLruEvictionRate(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_PUTSRATE: + region.setPutsRate(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_REGIONTYPE: + region.setRegionType(getStringAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_ENTRYSIZE: + region.setEntrySize(getLongAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_SYSTEMREGIONENTRYCOUNT: + region.setSystemRegionEntryCount(getLongAttribute( + attribute.getValue(), attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_MEMBERCOUNT: + region.setMemberCount(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_PERSISTENTENABLED: + region.setPersistentEnabled(getBooleanAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_NAME: + region.setName(getStringAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_GATEWAYENABLED: + region.setWanEnabled(getBooleanAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_DISKUSAGE: + region.setDiskUsage(getLongAttribute(attribute.getValue(), + attribute.getName())); + break; + } + } + + //add for each member + updateRegionOnMembers(regionObjectName, regionFullPath, region); + + cluster.addClusterRegion(regionFullPath, region); + cluster.getDeletedRegions().remove(region.getFullPath()); + // Memory Reads and writes + region.getPutsPerSecTrend().add(region.getPutsRate()); + region.getGetsPerSecTrend().add(region.getGetsRate()); + // Disk Reads and Writes + region.getDiskReadsPerSecTrend().add(region.getDiskReadsRate()); + region.getDiskWritesPerSecTrend().add(region.getDiskWritesRate()); + + } catch (InstanceNotFoundException infe) { + LOGGER.warning(infe); + } catch (ReflectionException re) { + LOGGER.warning(re); + } + } + + private static boolean isQuoted(String value) { + final int len = value.length(); + if (len < 2 || value.charAt(0) != '"' || value.charAt(len - 1) != '"') { + return false; + } else { + return true; + } + } + + private void updateClusterStatement(ObjectName mbeanName) throws IOException { + + try { + + AttributeList attributeList = this.mbs.getAttributes(mbeanName, + PulseConstants.STATEMENT_MBEAN_ATTRIBUTES); + // retrieve the full path of the region + String statementDefinition = mbeanName.getKeyProperty("name"); + + if (isQuoted(statementDefinition)) { + statementDefinition = ObjectName.unquote(statementDefinition); + } + + Cluster.Statement statement = cluster.getClusterStatements().get( + statementDefinition); + + if (null == statement) { + statement = new Cluster.Statement(); + statement.setQueryDefinition(statementDefinition); + } + + for (int i = 0; i < attributeList.size(); i++) { + Attribute attribute = (Attribute) attributeList.get(i); + String name = attribute.getName(); + switch (name){ + case PulseConstants.MBEAN_ATTRIBUTE_NUMTIMESCOMPILED: + statement.setNumTimesCompiled(getLongAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_NUMEXECUTION: + statement.setNumExecution(getLongAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_NUMEXECUTIONSINPROGRESS: + statement.setNumExecutionsInProgress(getLongAttribute( + attribute.getValue(), attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_NUMTIMESGLOBALINDEXLOOKUP: + statement.setNumTimesGlobalIndexLookup(getLongAttribute( + attribute.getValue(), attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_NUMROWSMODIFIED: + statement.setNumRowsModified(getLongAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_PARSETIME: + statement.setParseTime(getLongAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_BINDTIME: + statement.setBindTime(getLongAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_OPTIMIZETIME: + statement.setOptimizeTime(getLongAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_ROUTINGINFOTIME: + statement.setRoutingInfoTime(getLongAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_GENERATETIME: + statement.setGenerateTime(getLongAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_TOTALCOMPILATIONTIME: + statement.setTotalCompilationTime(getLongAttribute( + attribute.getValue(), attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_EXECUTIONTIME: + statement.setExecutionTime(getLongAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_PROJECTIONTIME: + statement.setProjectionTime(getLongAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_TOTALEXECUTIONTIME: + statement.setTotalExecutionTime(getLongAttribute( + attribute.getValue(), attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_ROWSMODIFICATIONTIME: + statement.setRowsModificationTime(getLongAttribute( + attribute.getValue(), attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_QNNUMROWSSEEN: + statement.setqNNumRowsSeen(getLongAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_QNMSGSENDTIME: + statement.setqNMsgSendTime(getLongAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_QNMSGSERTIME: + statement.setqNMsgSerTime(getLongAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_QNRESPDESERTIME: + statement.setqNRespDeSerTime(getLongAttribute(attribute.getValue(), + attribute.getName())); + break; + } + } + + cluster.addClusterStatement(statementDefinition, statement); + // TODO : to store data for sparklines later + /* + * region.getPutsPerSecTrend().add(region.getPutsRate()); + * region.getGetsPerSecTrend().add(region.getGetsRate()); + */ + } catch (InstanceNotFoundException infe) { + LOGGER.warning(infe); + } catch (ReflectionException re) { + LOGGER.warning(re); + } + } + + /** + * function used to iterate through all member attributes and return the + * updated member + */ + private Cluster.Member initializeMember(ObjectName mbeanName, + Cluster.Member member) throws InstanceNotFoundException, + ReflectionException, IOException { + + AttributeList attributeList = this.mbs.getAttributes(mbeanName, + PulseConstants.MEMBER_MBEAN_ATTRIBUTES); + + for (int i = 0; i < attributeList.size(); i++) { + + Attribute attribute = (Attribute) attributeList.get(i); + String name = attribute.getName(); + switch (name) { + case PulseConstants.MBEAN_ATTRIBUTE_GEMFIREVERSION: + if (member.getGemfireVersion() == null) { + // Set Member's GemFire Version if not set already + String gemfireVersion = obtainGemfireVersion(getStringAttribute( + attribute.getValue(), attribute.getName())); + member.setGemfireVersion(gemfireVersion); + } + break; + case PulseConstants.MBEAN_ATTRIBUTE_MANAGER: + member.setManager(getBooleanAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_TOTALREGIONCOUNT: + member.setTotalRegionCount(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_LOCATOR: + member.setLocator(getBooleanAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_TOTALDISKUSAGE: + member.setTotalDiskUsage(getLongAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_SERVER: + member.setServer(getBooleanAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_TOTALFILEDESCRIPTOROPEN: + member.setTotalFileDescriptorOpen(getLongAttribute( + attribute.getValue(), attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_LOADAVERAGE: + member.setLoadAverage(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_DISKWRITESRATE: + member.setThroughputWrites(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + member.getThroughputWritesTrend().add(member.getThroughputWrites()); + break; + case PulseConstants.MBEAN_ATTRIBUTE_DISKREADSRATE: + member.setThroughputReads(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + member.getThroughputReadsTrend().add(member.getThroughputReads()); + break; + case PulseConstants.MBEAN_ATTRIBUTE_JVMPAUSES: + long trendVal = determineCurrentJVMPauses( + PulseConstants.JVM_PAUSES_TYPE_MEMBER, member.getName(), + getLongAttribute(attribute.getValue(), + attribute.getName())); + member.setGarbageCollectionCount(trendVal); + member.getGarbageCollectionSamples().add( + member.getGarbageCollectionCount()); + break; + case PulseConstants.MBEAN_ATTRIBUTE_USEDMEMORY: + member.setCurrentHeapSize(getLongAttribute(attribute.getValue(), + attribute.getName())); + member.getHeapUsageSamples().add(member.getCurrentHeapSize()); + break; + case PulseConstants.MBEAN_ATTRIBUTE_MAXMEMORY: + member.setMaxHeapSize(getLongAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_NUMTHREADS: + member.setNumThreads(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_MEMBERUPTIME: + member.setUptime(getLongAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_HOST: + member.setHost(getStringAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_HOSTNAMEFORCLIENTS: + member.setHostnameForClients(getStringAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_BINDADDRESS: + member.setBindAddress(getStringAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_TOTALBYTESONDISK: + member.setTotalBytesOnDisk(getLongAttribute(attribute.getValue(), + attribute.getName())); + member.getTotalBytesOnDiskSamples().add(member.getTotalBytesOnDisk()); + break; + case PulseConstants.MBEAN_ATTRIBUTE_CPUUSAGE: + member.setCpuUsage(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + member.getCpuUsageSamples().add(member.getCpuUsage()); + break; + case PulseConstants.MBEAN_ATTRIBUTE_HOSTCPUUSAGE: + // Float value is expected for host cpu usage. + // TODO Remove Float.valueOf() when float value is provided in mbean + member.setHostCpuUsage(Double.valueOf(getIntegerAttribute( + attribute.getValue(), attribute.getName()))); + break; + case PulseConstants.MBEAN_ATTRIBUTE_MEMBER: + member.setName(getStringAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_ID: + member.setId(getStringAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_AVERAGEREADS: + member.setGetsRate(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + member.getGetsPerSecond().add(member.getGetsRate()); + break; + case PulseConstants.MBEAN_ATTRIBUTE_AVERAGEWRITES: + member.setPutsRate(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + member.getPutsPerSecond().add(member.getPutsRate()); + break; + case PulseConstants.MBEAN_ATTRIBUTE_OFFHEAPFREESIZE: + member.setOffHeapFreeSize(getLongAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_OFFHEAPUSEDSIZE: + member.setOffHeapUsedSize(getLongAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_SERVERGROUPS: + String sgValues[] = (String[]) attribute.getValue(); + member.getServerGroups().clear(); + for (int k = 0; k < sgValues.length; k++) { + member.getServerGroups().add(sgValues[k]); + } + break; + case PulseConstants.MBEAN_ATTRIBUTE_REDUNDANCYZONES: + String rzValue = ""; + if(null != attribute.getValue()){ + rzValue = getStringAttribute(attribute.getValue(), + attribute.getName()); + } + member.getRedundancyZones().clear(); + if(!rzValue.isEmpty()){ + member.getRedundancyZones().add(rzValue); + } + break; + } + } + + // SQLFire specific attributes + if (PulseController.getPulseProductSupport().equalsIgnoreCase( + PulseConstants.PRODUCT_NAME_SQLFIRE)) { + + try { + // get sqlfire mbeans + String memberName = mbeanName + .getKeyProperty(PulseConstants.MBEAN_KEY_PROPERTY_MEMBER); + + ObjectName sfMemberMbeansObjectName = new ObjectName( + PulseConstants.OBJECT_NAME_SF_MEMBER_PATTERN + memberName); + + Set<ObjectName> sfMemberMBeans = this.mbs.queryNames( + sfMemberMbeansObjectName, null); + for (ObjectName sfMemberMBean : sfMemberMBeans) { + + AttributeList attrList = this.mbs.getAttributes(sfMemberMBean, + PulseConstants.SF_MEMBER_MBEAN_ATTRIBUTES); + for (int i = 0; i < attrList.size(); i++) { + + Attribute attribute = (Attribute) attrList.get(i); + + if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_DATASTORE)) { + member.setServer(getBooleanAttribute(attribute.getValue(), + attribute.getName())); + + // Update Server count + if (member.isServer()) { + cluster.setServerCount(cluster.getServerCount() + 1); + } + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_NETWORKSERVERCLIENTCONNECTIONSTATS)) { + + CompositeData nscConnStats = (CompositeData) attribute.getValue(); + + // Update sqlfire client count + member.setNumSqlfireClients(getLongAttribute(nscConnStats + .get(PulseConstants.COMPOSITE_DATA_KEY_CONNECTIONSACTIVE), + PulseConstants.COMPOSITE_DATA_KEY_CONNECTIONSACTIVE)); + } + } + break; + } + + } catch (MalformedObjectNameException e) { + LOGGER.warning(e); + } catch (NullPointerException e) { + LOGGER.warning(e); + } + + } + + return member; + } + + /** + * function used to get attribute values of Cluster Member and map them to + * cluster member vo + * + * @param mbeanName + * Cluster Member MBean + */ + private void updateClusterMember(ObjectName mbeanName) throws IOException { + + try { + String memberName = mbeanName + .getKeyProperty(PulseConstants.MBEAN_KEY_PROPERTY_MEMBER); + + Cluster.Member clusterMember = cluster.getMembersHMap().get(memberName); + + if (clusterMember != null) // checking if member exists or not + { + cluster.getDeletedMembers().remove(memberName); + } else { + clusterMember = new Cluster.Member(); + cluster.getMembersHMap().put(memberName, clusterMember); + } + + // initialize member and add to cluster's member list + clusterMember = initializeMember(mbeanName, clusterMember); + ArrayList<Cluster.Member> memberArrList = (ArrayList<Cluster.Member>) cluster + .getPhysicalToMember().get(clusterMember.getHost()); + if (memberArrList != null) { + if (!memberArrList.contains(clusterMember)) { + memberArrList.add(clusterMember); + } + } else { + ArrayList<Cluster.Member> memberList = new ArrayList<Cluster.Member>(); + memberList.add(clusterMember); + cluster.getPhysicalToMember().put(clusterMember.getHost(), memberList); + } + } catch (InstanceNotFoundException infe) { + LOGGER.warning(infe); + } catch (ReflectionException re) { + LOGGER.warning(re); + } + } + + /** + * function used to handle Float data type if the value for mbean for an + * attribute is null then return 0.0 as default value else return the + * attribute value + */ + private Float getFloatAttribute(Object object, String name) { + if (object == null) { + return Float.valueOf(0.0f); + } + + try { + if (!(object.getClass().equals(Float.class))) { + if (LOGGER.infoEnabled()) { + LOGGER.info("************************Unexpected type for attribute: " + + name + " Expected type: " + Float.class.getName() + + " Received type: " + object.getClass().getName() + + "************************"); + } + return Float.valueOf(0.0f); + } else { + return (Float) object; + } + } catch (Exception e) { + if (LOGGER.infoEnabled()) { + LOGGER.info("Exception occurred: " + e.getMessage()); + } + return Float.valueOf(0.0f); + } + } + + /** + * function used to handle Integer data type if the value for mbean for an + * attribute is null then return 0 as default value else return the attribute + * value + */ + private Integer getIntegerAttribute(Object object, String name) { + if (object == null) { + return Integer.valueOf(0); + } + + try { + if (!(object.getClass().equals(Integer.class))) { + if (LOGGER.infoEnabled()) { + LOGGER.info("************************Unexpected type for attribute: " + + name + " Expected type: " + Integer.class.getName() + + " Received type: " + object.getClass().getName() + + "************************"); + } + return Integer.valueOf(0); + } else { + return (Integer) object; + } + } catch (Exception e) { + if (LOGGER.infoEnabled()) { + LOGGER.info("Exception occurred: " + e.getMessage()); + } + return Integer.valueOf(0); + } + } + + /** + * function used to handle Long data type if the value for mbean for an + * attribute is null then return 0 as default value else return the attribute + * value + */ + private Long getLongAttribute(Object object, String name) { + if (object == null) { + return Long.valueOf(0); + } + + try { + if (!(object.getClass().equals(Long.class))) { + if (LOGGER.infoEnabled()) { + LOGGER.info("************************Unexpected type for attribute: " + + name + " Expected type: " + Long.class.getName() + + " Received type: " + object.getClass().getName() + + "************************"); + } + return Long.valueOf(0); + } else { + return (Long) object; + } + } catch (Exception e) { + if (LOGGER.infoEnabled()) { + LOGGER.info("Exception occurred: " + e.getMessage()); + } + return Long.valueOf(0); + } + + } + + /** + * function used to handle String data type if the value for mbean for an + * attribute is null then return the empty string as default value else return + * the attribute value + */ + private String getStringAttribute(Object object, String name) { + if (object == null) { + return ""; + } + + try { + if (!(object.getClass().equals(String.class))) { + if (LOGGER.infoEnabled()) { + LOGGER.info("************************Unexpected type for attribute: " + + name + " Expected type: " + String.class.getName() + + " Received type: " + object.getClass().getName() + + "************************"); + } + return ""; + } else { + return (String) object; + } + } catch (Exception e) { + if (LOGGER.infoEnabled()) { + LOGGER.info("Exception occurred: " + e.getMessage()); + } + return ""; + } + } + + /** + * function used to handle Boolean data type if the value for mbean for an + * attribute is null then return false as default value else return the + * attribute value + */ + private Boolean getBooleanAttribute(Object object, String name) { + if (object == null) { + return Boolean.FALSE; + } + + try { + if (!(object.getClass().equals(Boolean.class))) { + if (LOGGER.infoEnabled()) { + LOGGER.info("************************Unexpected type for attribute: " + + name + " Expected type: " + Boolean.class.getName() + + " Received type: " + object.getClass().getName() + + "************************"); + } + return Boolean.FALSE; + } else { + return (Boolean) object; + } + } catch (Exception e) { + if (LOGGER.infoEnabled()) { + LOGGER.info("Exception Occured: " + e.getMessage()); + } + return Boolean.FALSE; + } + } + + /** + * function used to handle Double data type if the value for mbean for an + * attribute is null then return 0.0 as default value else return the + * attribute value + */ + private Double getDoubleAttribute(Object object, String name) { + if (object == null) { + return Double.valueOf(0); + } + + try { + if (!(object.getClass().equals(Double.class))) { + if (LOGGER.infoEnabled()) { + LOGGER.info("************************Unexpected type for attribute: " + + name + " Expected type: " + Double.class.getName() + + " Received type: " + object.getClass().getName() + + "************************"); + } + return Double.valueOf(0); + } else { + return (Double) object; + } + } catch (Exception e) { + if (LOGGER.infoEnabled()) { + LOGGER.info("Exception occurred: " + e.getMessage()); + } + return Double.valueOf(0); + } + } + + /** + * function used to get attribute values of Member Region and map them to + * Member vo + * + * @param mbeanName + * Member Region MBean + */ + private void updateMemberRegion(ObjectName mbeanName) throws IOException { + + try { + String memberName = mbeanName + .getKeyProperty(PulseConstants.MBEAN_KEY_PROPERTY_MEMBER); + + Cluster.Member member = cluster.getMembersHMap().get(memberName); + + //Following attributes are not present in 9.0 + //"Members" + //"EmptyNodes" + //"SystemRegionEntryCount" + //"MemberCount" + AttributeList attributeList = this.mbs.getAttributes(mbeanName, + PulseConstants.REGION_MBEAN_ATTRIBUTES); + + // retrieve the full path of the region + String regionFullPathKey = null; + for (int i = 0; i < attributeList.size(); i++) { + Attribute attribute = (Attribute) attributeList.get(i); + + if (attribute.getName().equals(PulseConstants.MBEAN_ATTRIBUTE_FULLPATH)) { + regionFullPathKey = getStringAttribute(attribute.getValue(), + attribute.getName()); + break; + } + } + + // if member does not exists defined for this region then create a member + if (null == member) { + member = new Cluster.Member(); + member.setName(memberName); + cluster.getMembersHMap().put(memberName, member); + } + + // if region with given path exists then update same else add new region + Cluster.Region region = member.getMemberRegions().get(regionFullPathKey); + if (null == region) { + region = new Cluster.Region(); + member.getMemberRegions().put(regionFullPathKey, region); + member.setTotalRegionCount(member.getTotalRegionCount() + 1); + } + region.setFullPath(regionFullPathKey); // use already retrieved values + + // update the existing or new region + for (int i = 0; i < attributeList.size(); i++) { + Attribute attribute = (Attribute) attributeList.get(i); + String name = attribute.getName(); + switch (name){ + case PulseConstants.MBEAN_ATTRIBUTE_FULLPATH: + region.setFullPath(getStringAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_DISKREADSRATE: + region.setDiskReadsRate(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_DISKWRITESRATE: + region.setDiskWritesRate(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN_ATTRIBUTE_GETSRATE: + region.setGetsRate(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + break; + case PulseConstants.MBEAN
<TRUNCATED>