Return-Path: X-Original-To: apmail-geode-commits-archive@minotaur.apache.org Delivered-To: apmail-geode-commits-archive@minotaur.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id F2329187F0 for ; Tue, 3 Nov 2015 11:26:02 +0000 (UTC) Received: (qmail 66387 invoked by uid 500); 3 Nov 2015 11:26:02 -0000 Delivered-To: apmail-geode-commits-archive@geode.apache.org Received: (qmail 66360 invoked by uid 500); 3 Nov 2015 11:26:02 -0000 Mailing-List: contact commits-help@geode.incubator.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@geode.incubator.apache.org Delivered-To: mailing list commits@geode.incubator.apache.org Received: (qmail 66351 invoked by uid 99); 3 Nov 2015 11:26:02 -0000 Received: from Unknown (HELO spamd1-us-west.apache.org) (209.188.14.142) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 03 Nov 2015 11:26:02 +0000 Received: from localhost (localhost [127.0.0.1]) by spamd1-us-west.apache.org (ASF Mail Server at spamd1-us-west.apache.org) with ESMTP id 27A60C29AA for ; Tue, 3 Nov 2015 11:26:02 +0000 (UTC) X-Virus-Scanned: Debian amavisd-new at spamd1-us-west.apache.org X-Spam-Flag: NO X-Spam-Score: 1.771 X-Spam-Level: * X-Spam-Status: No, score=1.771 tagged_above=-999 required=6.31 tests=[KAM_ASCII_DIVIDERS=0.8, KAM_LAZY_DOMAIN_SECURITY=1, RCVD_IN_MSPIKE_H3=-0.01, RCVD_IN_MSPIKE_WL=-0.01, T_RP_MATCHES_RCVD=-0.01, URIBL_BLOCKED=0.001] autolearn=disabled Received: from mx1-us-west.apache.org ([10.40.0.8]) by localhost (spamd1-us-west.apache.org [10.40.0.7]) (amavisd-new, port 10024) with ESMTP id K3eF_dIcgBwM for ; Tue, 3 Nov 2015 11:25:54 +0000 (UTC) Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by mx1-us-west.apache.org (ASF Mail Server at mx1-us-west.apache.org) with SMTP id CB26C238A2 for ; Tue, 3 Nov 2015 11:25:24 +0000 (UTC) Received: (qmail 62018 invoked by uid 99); 3 Nov 2015 11:25:24 -0000 Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 03 Nov 2015 11:25:24 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id A1E79E01FB; Tue, 3 Nov 2015 11:25:24 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: tushark@apache.org To: commits@geode.incubator.apache.org Date: Tue, 03 Nov 2015 11:26:03 -0000 Message-Id: <119e48105b8d4add8a6877c587163f60@git.apache.org> In-Reply-To: References: X-Mailer: ASF-Git Admin Mailer Subject: [41/79] [partial] incubator-geode git commit: GEODE-12: Imported pulse from geode-1.0.0-SNAPSHOT-2.src.tar http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/1922937f/pulse/src/main/java/com/vmware/gemfire/tools/pulse/internal/data/JMXDataUpdater.java ---------------------------------------------------------------------- diff --git a/pulse/src/main/java/com/vmware/gemfire/tools/pulse/internal/data/JMXDataUpdater.java b/pulse/src/main/java/com/vmware/gemfire/tools/pulse/internal/data/JMXDataUpdater.java new file mode 100644 index 0000000..27aed67 --- /dev/null +++ b/pulse/src/main/java/com/vmware/gemfire/tools/pulse/internal/data/JMXDataUpdater.java @@ -0,0 +1,2529 @@ +/* + * ========================================================================= + * Copyright (c) 2012-2014 Pivotal Software, Inc. All Rights Reserved. + * This product is protected by U.S. and international copyright + * and intellectual property laws. Pivotal products are covered by + * more patents listed at http://www.pivotal.io/patents. + * ======================================================================== + */ + +package com.vmware.gemfire.tools.pulse.internal.data; + +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; + +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 com.vmware.gemfire.tools.pulse.internal.controllers.PulseController; +import com.vmware.gemfire.tools.pulse.internal.data.JmxManagerFinder.JmxManagerInfo; +import com.vmware.gemfire.tools.pulse.internal.json.JSONException; +import com.vmware.gemfire.tools.pulse.internal.json.JSONObject; +import com.vmware.gemfire.tools.pulse.internal.log.PulseLogWriter; +import com.vmware.gemfire.tools.pulse.internal.util.StringUtils; + +/** + * Class JMXDataUpdater Class used for creating JMX connection and getting all + * the required MBeans + * + * @author Anand Hariharan + * + * @since 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 systemMBeans = null; + + private final String opSignature[] = { String.class.getName(), + String.class.getName(), int.class.getName() }; + + /** + * 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 JMXConnector getJMXConnection() { + 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()) { + + 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) { + // Locator has IPv4 Address + if (LOGGER.infoEnabled()) { + LOGGER.info(resourceBundle + .getString("LOG_MSG_LOCATOR_IPV4_ADDRESS") + + " - " + + inetAddr.toString()); + } + } else { + // Locator has IPv6 Address + 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")); + } + } 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 (inetAddr instanceof Inet6Address) { // Locator has IPv6 + * Address if(LOGGER.infoEnabled()){ + * LOGGER.info(resourceBundle.getString + * ("LOG_MSG_LOCATOR_IPV6_ADDRESS")); } // update message to display + * on UI cluster.setConnectionErrorMsg(resourceBundle.getString( + * "LOG_MSG_JMX_CONNECTION_IPv6_ADDRESS")); + * + * } + */else { + // Locator has Invalid locator Address + if (LOGGER.infoEnabled()) { + LOGGER + .info(resourceBundle.getString("LOG_MSG_LOCATOR_BAD_ADDRESS")); + } + // update message to display on UI + cluster.setConnectionErrorMsg(resourceBundle + .getString("LOG_MSG_JMX_CONNECTION_BAD_ADDRESS")); + + } + + } 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 = {"controlRole", "R&D"}; + String[] creds = { this.userName, this.userPassword }; + Map env = new HashMap(); + + env.put(JMXConnector.CREDENTIALS, creds); + + if (repository.isUseSSLManager()) { + // use ssl to connect + env.put("com.sun.jndi.rmi.factory.socket", + new SslRMIClientSocketFactory()); + } + + connection = JMXConnectorFactory.connect(url, env); + + // Register Pulse URL if not already present in the JMX Manager + registerPulseUrlToManager(connection); + } + } catch (Exception e) { + if (e instanceof UnknownHostException) { + // update message to display on UI + cluster.setConnectionErrorMsg(resourceBundle + .getString("LOG_MSG_JMX_CONNECTION_UNKNOWN_HOST")); + } + + // write errors + 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 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 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 regionMBeans = this.mbs.queryNames( + this.MBEAN_OBJECT_NAME_REGION_DISTRIBUTED, null); + + Set 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 it = cluster.getDeletedRegions().iterator(); it + .hasNext();) { + cluster.removeClusterRegion(it.next()); + } + + // Cluster Members + Set memberMBeans = this.mbs.queryNames( + this.MBEAN_OBJECT_NAME_MEMBER, null); + for (ObjectName memMBean : memberMBeans) { + // member regions + if (memMBean.getKeyProperty(PulseConstants.MBEAN_KEY_PROPERTY_SERVICE) != null) { + if (memMBean + .getKeyProperty(PulseConstants.MBEAN_KEY_PROPERTY_SERVICE) + .equals(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); + } + + } else if (memMBean.getKeyProperty( + PulseConstants.MBEAN_KEY_PROPERTY_SERVICE).equals( + PulseConstants.MBEAN_KEY_PROPERTY_SERVICE_VALUE_CACHESERVER)) { + updateMemberClient(memMBean); + } + // Gateway Receiver Attributes + else if (memMBean.getKeyProperty( + PulseConstants.MBEAN_KEY_PROPERTY_SERVICE).equals( + PulseConstants.MBEAN_KEY_PROPERTY_SERVICE_VALUE_GATEWAYRECEIVER)) { + updateGatewayReceiver(memMBean); + } else if (memMBean.getKeyProperty( + PulseConstants.MBEAN_KEY_PROPERTY_SERVICE).equals( + PulseConstants.MBEAN_KEY_PROPERTY_SERVICE_VALUE_GATEWAYSENDER)) { + updateGatewaySender(memMBean); + } else if(memMBean.getKeyProperty( + PulseConstants.MBEAN_KEY_PROPERTY_SERVICE).equals( + PulseConstants.MBEAN_KEY_PROPERTY_SERVICE_VALUE_ASYNCEVENTQUEUE)){ + + // AsyncEventQueue + updateAsyncEventQueue(memMBean); + } + } else { + // Cluster Member + updateClusterMember(memMBean); + } + } + + // Cluster Query Statistics + Set 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 iterator = cluster.getDeletedMembers().iterator(); + while (iterator.hasNext()) { + String memberKey = iterator.next(); + if (cluster.getMembersHMap().containsKey(memberKey)) { + Cluster.Member member = cluster.getMembersHMap().get(memberKey); + List 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 rows = (Collection) 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); + + if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_MEMBERCOUNT)) { + cluster.setMemberCount(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_NUMCLIENTS)) { + cluster.setClientConnectionCount(getIntegerAttribute( + attribute.getValue(), attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_DISTRIBUTEDSYSTEMID)) { + cluster.setClusterId(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_LOCATORCOUNT)) { + cluster.setLocatorCount(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_NUMRUNNIGFUNCTION)) { + try { + cluster.setRunningFunctionCount(getIntegerAttribute( + attribute.getValue(), attribute.getName())); + } catch (Exception e) { + cluster.setRunningFunctionCount(0); + continue; + } + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_REGISTEREDCQCOUNT)) { + cluster.setRegisteredCQCount(getLongAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_NUMSUBSCRIPTIONS)) { + cluster.setSubscriptionCount(getIntegerAttribute( + attribute.getValue(), attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_NUMTXNCOMMITTED)) { + cluster.setTxnCommittedCount(getIntegerAttribute( + attribute.getValue(), attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_NUMTXNROLLBACK)) { + cluster.setTxnRollbackCount(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_TOTALHEAPSIZE)) { + cluster.setTotalHeapSize(getLongAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + 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()); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_TOTALREGIONENTRYCOUNT)) { + cluster.setTotalRegionEntryCount(getLongAttribute( + attribute.getValue(), attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_CURRENTENTRYCOUNT)) { + cluster.setCurrentQueryCount(getIntegerAttribute( + attribute.getValue(), attribute.getName())); + } else if (attribute.getName().equals( + 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()); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_DISKWRITESRATE)) { + cluster.setDiskWritesRate(getFloatAttribute(attribute.getValue(), + attribute.getName())); + cluster.getThroughoutWritesTrend().add(cluster.getDiskWritesRate()); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_AVERAGEWRITES)) { + try { + cluster.setWritePerSec(getFloatAttribute(attribute.getValue(), + attribute.getName())); + } catch (Exception e) { + cluster.setWritePerSec(0); + continue; + } + cluster.getWritePerSecTrend().add(cluster.getWritePerSec()); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_AVERAGEREADS)) { + try { + cluster.setReadPerSec(getFloatAttribute(attribute.getValue(), + attribute.getName())); + } catch (Exception e) { + cluster.setReadPerSec(0); + continue; + } + cluster.getReadPerSecTrend().add(cluster.getReadPerSec()); + + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_QUERYREQUESTRATE)) { + cluster.setQueriesPerSec(getFloatAttribute(attribute.getValue(), + attribute.getName())); + cluster.getQueriesPerSecTrend().add(cluster.getQueriesPerSec()); + + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_DISKREADSRATE)) { + cluster.setDiskReadsRate(getFloatAttribute(attribute.getValue(), + attribute.getName())); + cluster.getThroughoutReadsTrend().add(cluster.getDiskReadsRate()); + } else if (attribute.getName().equals( + 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()); + + } + + // For SQLfire or Gemfire + if (PulseConstants.PRODUCT_NAME_SQLFIRE + .equalsIgnoreCase(PulseController.getPulseProductSupport())) { + // For SQLfire + // Do nothing + } else { + // For Gemfire + if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_TOTALREGIONCOUNT)) { + cluster.setTotalRegionCount(getIntegerAttribute( + attribute.getValue(), attribute.getName())); + } + } + + } + + // 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 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(getFloatAttribute( + 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); + if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_EVENTRECEIVEDDATE)) { + gatewaySender.setLinkThroughput(getFloatAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_BATCHSIZE)) { + gatewaySender.setBatchSize(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_SENDERID)) { + gatewaySender.setId(getStringAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_EVENTQUEUESIZE)) { + gatewaySender.setQueueSize(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_RUNNING)) { + gatewaySender.setStatus(getBooleanAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_PRIMARY)) { + gatewaySender.setPrimary(getBooleanAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_PERSISTENCEENABLED)) { + gatewaySender.setPersistenceEnabled(getBooleanAttribute( + attribute.getValue(), attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_PARALLEL)) { + gatewaySender.setSenderType(getBooleanAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_REMOTE_DS_ID)) { + gatewaySender.setRemoteDSId(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_EVENTS_EXCEEDING_ALERT_THRESHOLD)) { + gatewaySender.setEventsExceedingAlertThreshold(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + } + } + 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 + * + * @param mbeanName + * @param memberName + * @throws InstanceNotFoundException + * @throws IntrospectionException + * @throws ReflectionException + * @throws IOException + * @throws AttributeNotFoundException + * @throws MBeanException + * + */ + 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 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); + if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_AEQ_ASYNCEVENTID)) { + asyncEventQueue.setId(getStringAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_AEQ_ASYNC_EVENT_LISTENER)) { + asyncEventQueue.setAsyncEventListener(getStringAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_AEQ_BATCH_CONFLATION_ENABLED)) { + asyncEventQueue.setBatchConflationEnabled(getBooleanAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_AEQ_BATCH_TIME_INTERVAL)) { + asyncEventQueue.setBatchTimeInterval(getLongAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_AEQ_BATCH_SIZE)) { + asyncEventQueue.setBatchSize(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_AEQ_EVENT_QUEUE_SIZE)) { + asyncEventQueue.setEventQueueSize(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_AEQ_PARALLEL)) { + asyncEventQueue.setParallel(getBooleanAttribute( + attribute.getValue(), attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_AEQ_PRIMARY)) { + asyncEventQueue.setPrimary(getBooleanAttribute(attribute.getValue(), + attribute.getName())); + } + } + 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 + * + * @param mbeanName + * @param memberName + * @throws InstanceNotFoundException + * @throws IntrospectionException + * @throws ReflectionException + * @throws IOException + * @throws AttributeNotFoundException + * @throws MBeanException + * + */ + 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 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 + * + * @param mbeanName + * @param memberName + * @throws InstanceNotFoundException + * @throws IntrospectionException + * @throws ReflectionException + * @throws IOException + * @throws AttributeNotFoundException + * @throws MBeanException + * + */ + 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 + * + * @param mbeanName + * @param memberName + * @throws InstanceNotFoundException + * @throws IntrospectionException + * @throws ReflectionException + * @throws IOException + * @throws MBeanException + * @throws AttributeNotFoundException + * + */ + 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 memberClientsHM = new HashMap(); + + existingMember.setMemberPort("" + + this.mbs.getAttribute(mbeanName, + PulseConstants.MBEAN_ATTRIBUTE_PORT)); + + 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 regionFullPath + * @param region + */ + private void updateRegionOnMembers(String regionFullPath, Cluster.Region region) throws IOException { + + try{ + List memberNamesTemp = region.getMemberName(); + ArrayList memberNames = new ArrayList(memberNamesTemp); + + List regionOnMemberList = new ArrayList(); + List regionOnMemberListNew = new ArrayList(); + Cluster.RegionOnMember[] regionOnMemberNames = region.getRegionOnMembers(); + + if ((regionOnMemberNames != null) && (regionOnMemberNames.length > 0)) { + regionOnMemberList = new ArrayList(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 + regionFullPath + 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); + if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_ENTRYSIZE)) { + anRom.setEntrySize(getLongAttribute(attribute.getValue(), + attribute.getName())); + LOGGER.fine("updateRegionOnMembers : anRom.getEntrySize() = " + anRom.getEntrySize()); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_ENTRYCOUNT)) { + anRom.setEntryCount(getLongAttribute(attribute.getValue(), + attribute.getName())); + LOGGER.fine("updateRegionOnMembers : anRom.getEntryCount() = " + anRom.getEntryCount()); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_PUTSRATE)) { + anRom.setPutsRate(getFloatAttribute(attribute.getValue(), + attribute.getName())); + LOGGER.fine("updateRegionOnMembers : anRom.getPutsRate() = " + anRom.getPutsRate()); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_GETSRATE)) { + anRom.setGetsRate(getFloatAttribute(attribute.getValue(), + attribute.getName())); + LOGGER.fine("updateRegionOnMembers : anRom.getGetsRate() = " + anRom.getGetsRate()); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_DISKREADSRATE)) { + anRom.setDiskGetsRate(getFloatAttribute(attribute.getValue(), + attribute.getName())); + LOGGER.fine("updateRegionOnMembers : anRom.getDiskGetsRate() = " + anRom.getDiskGetsRate()); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_DISKWRITESRATE)) { + anRom.setDiskPutsRate(getFloatAttribute(attribute.getValue(), + attribute.getName())); + LOGGER.fine("updateRegionOnMembers : anRom.getDiskPutsRate() = " + anRom.getDiskPutsRate()); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_LOCALMAXMEMORY)) { + anRom.setLocalMaxMemory(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + LOGGER.fine("updateRegionOnMembers : anRom.getLocalMaxMemory() = " + anRom.getLocalMaxMemory()); + } + } + + 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 + regionFullPath + 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); + if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_ENTRYSIZE)) { + regionOnMember.setEntrySize(getLongAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_ENTRYCOUNT)) { + regionOnMember.setEntryCount(getLongAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_PUTSRATE)) { + regionOnMember.setPutsRate(getFloatAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_GETSRATE)) { + regionOnMember.setGetsRate(getFloatAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_DISKREADSRATE)) { + regionOnMember.setDiskGetsRate(getFloatAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_DISKWRITESRATE)) { + regionOnMember.setDiskPutsRate(getFloatAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_LOCALMAXMEMORY)) { + regionOnMember.setLocalMaxMemory(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + } + } + + 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 + * @throws IOException + * @throws ReflectionException + * @throws IntrospectionException + * @throws InstanceNotFoundException + * @throws MBeanException + * @throws AttributeNotFoundException + */ + 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 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); + + if (attribute.getName().equals(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]); + } + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_FULLPATH)) { + region.setFullPath(getStringAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_DISKREADSRATE)) { + region.setDiskReadsRate(getFloatAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_DISKWRITESRATE)) { + region.setDiskWritesRate(getFloatAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_EMPTYNODES)) { + region.setEmptyNode(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_GETSRATE)) { + region.setGetsRate(getFloatAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_LRUEVICTIONRATE)) { + region.setLruEvictionRate(getFloatAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_PUTSRATE)) { + region.setPutsRate(getFloatAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_REGIONTYPE)) { + region.setRegionType(getStringAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_ENTRYSIZE)) { + region.setEntrySize(getLongAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_SYSTEMREGIONENTRYCOUNT)) { + region.setSystemRegionEntryCount(getLongAttribute( + attribute.getValue(), attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_MEMBERCOUNT)) { + region.setMemberCount(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_PERSISTENTENABLED)) { + region.setPersistentEnabled(getBooleanAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_NAME)) { + region.setName(getStringAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_GATEWAYENABLED)) { + region.setWanEnabled(getBooleanAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_DISKUSAGE)) { + region.setDiskUsage(getLongAttribute(attribute.getValue(), + attribute.getName())); + } + } + + try{// Added for Rolling upgrade + CompositeData compositeData = (CompositeData) (this.mbs.invoke(mbeanName, + PulseConstants.MBEAN_OPERATION_LISTREGIONATTRIBUTES, null, null)); + + if (compositeData != null) { + if (compositeData + .containsKey(PulseConstants.COMPOSITE_DATA_KEY_COMPRESSIONCODEC)) { + String regCompCodec = (String) compositeData + .get(PulseConstants.COMPOSITE_DATA_KEY_COMPRESSIONCODEC); + if (null != regCompCodec) { + region.setCompressionCodec(regCompCodec); + } + } + if (compositeData + .containsKey(PulseConstants.COMPOSITE_DATA_KEY_ENABLEOFFHEAPMEMORY)) { + region.setEnableOffHeapMemory((Boolean) compositeData + .get(PulseConstants.COMPOSITE_DATA_KEY_ENABLEOFFHEAPMEMORY)); + } + if (compositeData + .containsKey(PulseConstants.COMPOSITE_DATA_KEY_HDFSWRITEONLY)) { + region.setHdfsWriteOnly((Boolean) compositeData + .get(PulseConstants.COMPOSITE_DATA_KEY_HDFSWRITEONLY)); + } + } + } catch (MBeanException anfe) { + LOGGER.warning(anfe); + region.setHdfsWriteOnly(false); + region.setEnableOffHeapMemory(false); + region.setCompressionCodec("NA"); + }catch (javax.management.RuntimeMBeanException invalidOe) { + region.setHdfsWriteOnly(false); + region.setEnableOffHeapMemory(false); + region.setCompressionCodec("NA"); + // LOGGER.info("Some of the Pulse elements are not available currently. There might be a GemFire upgrade going on."); + } + + + // TODO : Uncomment below code when sql fire mbean attributes are + // available + /* + * // IF SQLFIRE if + * (PulseConstants.PRODUCT_NAME_SQLFIRE.equalsIgnoreCase(PulseController + * .getPulseProductSupport())) { + * + * try { String tableName = this.getTableNameFromRegionName(region + * .getFullPath()); + * + * ObjectName tableObjName = new ObjectName( + * PulseConstants.OBJECT_NAME_TABLE_AGGREGATE_PATTERN + tableName); + * + * AttributeList tableAttributeList = this.mbs.getAttributes( + * tableObjName, PulseConstants.SF_TABLE_MBEAN_ATTRIBUTES); + * + * for (int i = 0; i < tableAttributeList.size(); i++) { + * + * Attribute attribute = (Attribute) tableAttributeList.get(i); + * + * if (attribute.getName().equals( + * PulseConstants.MBEAN_ATTRIBUTE_ENTRYSIZE)) { + * System.out.println("[SQLfire] setting entry size"); + * region.setEntrySize(getLongAttribute(attribute.getValue(), + * attribute.getName())); } else if (attribute.getName().equals( + * PulseConstants.MBEAN_ATTRIBUTE_NUMBEROFROWS)) { + * System.out.println("[SQLfire] setting num of rows"); + * region.setSystemRegionEntryCount(getLongAttribute( + * attribute.getValue(), attribute.getName())); } } } catch + * (MalformedObjectNameException e) { LOGGER.warning(e); } catch + * (NullPointerException e) { LOGGER.warning(e); } } + */ + + // Add to map even if region is present. If region is already there it + // will be a no-op. + + //add for each member + updateRegionOnMembers(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); + + if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_NUMTIMESCOMPILED)) { + statement.setNumTimesCompiled(getLongAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_NUMEXECUTION)) { + statement.setNumExecution(getLongAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_NUMEXECUTIONSINPROGRESS)) { + statement.setNumExecutionsInProgress(getLongAttribute( + attribute.getValue(), attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_NUMTIMESGLOBALINDEXLOOKUP)) { + statement.setNumTimesGlobalIndexLookup(getLongAttribute( + attribute.getValue(), attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_NUMROWSMODIFIED)) { + statement.setNumRowsModified(getLongAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_PARSETIME)) { + statement.setParseTime(getLongAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_BINDTIME)) { + statement.setBindTime(getLongAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_OPTIMIZETIME)) { + statement.setOptimizeTime(getLongAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_ROUTINGINFOTIME)) { + statement.setRoutingInfoTime(getLongAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_GENERATETIME)) { + statement.setGenerateTime(getLongAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_TOTALCOMPILATIONTIME)) { + statement.setTotalCompilationTime(getLongAttribute( + attribute.getValue(), attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_EXECUTIONTIME)) { + statement.setExecutionTime(getLongAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_PROJECTIONTIME)) { + statement.setProjectionTime(getLongAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_TOTALEXECUTIONTIME)) { + statement.setTotalExecutionTime(getLongAttribute( + attribute.getValue(), attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_ROWSMODIFICATIONTIME)) { + statement.setRowsModificationTime(getLongAttribute( + attribute.getValue(), attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_QNNUMROWSSEEN)) { + statement.setqNNumRowsSeen(getLongAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_QNMSGSENDTIME)) { + statement.setqNMsgSendTime(getLongAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_QNMSGSERTIME)) { + statement.setqNMsgSerTime(getLongAttribute(attribute.getValue(), + attribute.getName())); + } + if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_QNRESPDESERTIME)) { + statement.setqNRespDeSerTime(getLongAttribute(attribute.getValue(), + attribute.getName())); + } + } + + 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 + * + * @param attrs + * @param mbeanName + * @param member + * @return + * @throws IOException + * @throws ReflectionException + * @throws InstanceNotFoundException + */ + 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); + + if (attribute.getName().equals(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); + } + } else if (attribute.getName().equals(PulseConstants.MBEAN_ATTRIBUTE_MANAGER)) { + member.setManager(getBooleanAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_TOTALREGIONCOUNT)) { + member.setTotalRegionCount(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_LOCATOR)) { + member.setLocator(getBooleanAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_TOTALDISKUSAGE)) { + member.setTotalDiskUsage(getLongAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_SERVER)) { + member.setServer(getBooleanAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_TOTALFILEDESCRIPTOROPEN)) { + member.setTotalFileDescriptorOpen(getLongAttribute( + attribute.getValue(), attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_LOADAVERAGE)) { + member.setLoadAverage(getDoubleAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_DISKWRITESRATE)) { + member.setThroughputWrites(getFloatAttribute(attribute.getValue(), + attribute.getName())); + member.getThroughputWritesTrend().add(member.getThroughputWrites()); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_DISKREADSRATE)) { + member.setThroughputReads(getFloatAttribute(attribute.getValue(), + attribute.getName())); + member.getThroughputReadsTrend().add(member.getThroughputReads()); + } else if (attribute.getName().equals( + 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()); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_USEDMEMORY)) { + member.setCurrentHeapSize(getLongAttribute(attribute.getValue(), + attribute.getName())); + member.getHeapUsageSamples().add(member.getCurrentHeapSize()); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_MAXMEMORY)) { + member.setMaxHeapSize(getLongAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_NUMTHREADS)) { + member.setNumThreads(getIntegerAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_MEMBERUPTIME)) { + member.setUptime(getLongAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName() + .equals(PulseConstants.MBEAN_ATTRIBUTE_HOST)) { + member.setHost(getStringAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_TOTALBYTESONDISK)) { + member.setTotalBytesOnDisk(getLongAttribute(attribute.getValue(), + attribute.getName())); + member.getTotalBytesOnDiskSamples().add(member.getTotalBytesOnDisk()); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_CPUUSAGE)) { + member.setCpuUsage(getFloatAttribute(attribute.getValue(), + attribute.getName())); + member.getCpuUsageSamples().add(member.getCpuUsage()); + } else if (attribute.getName().equals( + 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(Float.valueOf(getIntegerAttribute( + attribute.getValue(), attribute.getName()))); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_MEMBER)) { + member.setName(getStringAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals(PulseConstants.MBEAN_ATTRIBUTE_ID)) { + member.setId(getStringAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_AVERAGEREADS)) { + member.setGetsRate(getFloatAttribute(attribute.getValue(), + attribute.getName())); + member.getGetsPerSecond().add(member.getGetsRate()); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_AVERAGEWRITES)) { + member.setPutsRate(getFloatAttribute(attribute.getValue(), + attribute.getName())); + member.getPutsPerSecond().add(member.getPutsRate()); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_OFFHEAPFREESIZE)) { + member.setOffHeapFreeSize(getLongAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_OFFHEAPUSEDSIZE)) { + member.setOffHeapUsedSize(getLongAttribute(attribute.getValue(), + attribute.getName())); + } else if (attribute.getName().equals( + 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]); + } + } else if (attribute.getName().equals( + PulseConstants.MBEAN_ATTRIBUTE_REDUNDANCYZONES)) { + /*String rzValues[] = (String[]) attribute.getValue(); + member.getRedundancyZones().clear(); + for (int k = 0; k < rzValues.length; k++) { + member.getRedundancyZones().add(rzValues[k]); + }*/ + + String rzValue = ""; + if(null != attribute.getValue()){ + rzValue = getStringAttribute(attribute.getValue(), + attribute.getName()); + } + member.getRedundancyZones().clear(); + if(!rzValue.isEmpty()){ + member.getRedundancyZones().add(rzValue); + } + } + } + + // 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 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 + * @throws IOException + * @throws ReflectionException + * @throws IntrospectionException + * @throws InstanceNotFoundException + * @throws MBeanException + * @throws AttributeNotFoundException + * + */ + 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 memberArrList = (ArrayList) cluster + .getPhysicalToMember().get(clusterMember.getHost()); + if (memberArrList != null) { + if (!memberArrList.contains(clusterMember)) { + memberArrList.add(clusterMember); + } + } else { + ArrayList memberList = new ArrayList(); + memberList.add(clusterMember); + cluster.getPhysicalToMember().put(clusterMember.getHost(), memberList); + } + } catch (InstanceNotFoundException infe) { + LOGGER.warning(infe); + } catch (ReflectionException re) { + LOGGER.warning(re); + } + } + + // /** + // * function used for creating member key with a combination + // * of member id and and member name + // * in key we are replacing ":" with "-" for both member id and name + // * @param id + // * @param name + // * @return + // */ + // private String getMemberNameOrId(String id, String name){ + // String key; + // if (id != null) { + // id = id.replace(":", "-"); + // } + // if (name != null) { + // name = name.replace(":", "-"); + // } + // key = id+name; + // return key; + // } + /** + * 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 + * + * @param name + * @param mbs + * @param mBeanName + * @return + */ + private Float getFloatAttribute(Object object, String name) { + 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 Occured: " + e.getMessage()); + } + return Float.valueOf(0.0f); + } + } + + /** + * function used to handle Integer data type if the value for mbean for an +