You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@geode.apache.org by hi...@apache.org on 2016/09/09 21:44:07 UTC
[70/83] [abbrv] incubator-geode git commit: GEODE-37 renamed pulse
package
http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/eff7f216/geode-pulse/src/main/java/org/apache/geode/tools/pulse/internal/data/Cluster.java
----------------------------------------------------------------------
diff --git a/geode-pulse/src/main/java/org/apache/geode/tools/pulse/internal/data/Cluster.java b/geode-pulse/src/main/java/org/apache/geode/tools/pulse/internal/data/Cluster.java
new file mode 100644
index 0000000..7bf44ff
--- /dev/null
+++ b/geode-pulse/src/main/java/org/apache/geode/tools/pulse/internal/data/Cluster.java
@@ -0,0 +1,3815 @@
+/*
+ *
+ * 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 org.apache.geode.tools.pulse.internal.data;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ArrayNode;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import org.apache.geode.tools.pulse.internal.log.PulseLogWriter;
+import org.apache.geode.tools.pulse.internal.util.StringUtils;
+import org.apache.commons.collections.buffer.CircularFifoBuffer;
+
+import javax.management.remote.JMXConnector;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.net.ConnectException;
+import java.net.URL;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Random;
+import java.util.ResourceBundle;
+import java.util.Set;
+import java.util.TimeZone;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+/**
+ * Class Cluster This class is the Data Model for the data used for the Pulse
+ * Web UI.
+ *
+ * @since GemFire version 7.0.Beta 2012-09-23
+ */
+public class Cluster extends Thread {
+ private static final int POLL_INTERVAL = 5000;
+ public static final int MAX_SAMPLE_SIZE = 180;
+ public static final int ALERTS_MAX_SIZE = 1000;
+ public static final int PAGE_ALERTS_MAX_SIZE = 100;
+
+ private final PulseLogWriter LOGGER = PulseLogWriter.getLogger();
+ private final ResourceBundle resourceBundle = Repository.get()
+ .getResourceBundle();
+
+ private String jmxUserName;
+ private String jmxUserPassword;
+ private String serverName;
+ private String port;
+ private int stale = 0;
+ private double loadPerSec;
+
+ // start: fields defined in System MBean
+ private IClusterUpdater updater = null;
+ private DataBrowser dataBrowser = null;
+ private int memberCount;
+ private long clientConnectionCount;
+ private int locatorCount;
+ private int totalRegionCount;
+ private long totalHeapSize = 0L;
+ private long totalRegionEntryCount;
+ private int currentQueryCount;
+ private long totalBytesOnDisk;
+ private double diskReadsRate;
+ private double diskWritesRate;
+ private double writePerSec;
+ private double readPerSec;
+ private double queriesPerSec;
+ private int avgDiskStorage;
+ private int avgDiskWritesRate;
+ private int runningFunctionCount;
+ private long registeredCQCount;
+ private int subscriptionCount;
+ private int serverCount;
+ private int txnCommittedCount;
+ private int txnRollbackCount;
+ private long usedHeapSize = 0L;
+ private long garbageCollectionCount = 0L;
+ private int clusterId;
+ private int notificationPageNumber = 1;
+ private boolean connectedFlag;
+ private String connectionErrorMsg = "";
+
+ private Set<String> deletedMembers = new HashSet<String>();
+
+ private Map<String, List<Cluster.Member>> physicalToMember = new HashMap<String, List<Cluster.Member>>();
+
+ private Map<String, Cluster.Member> membersHMap = new HashMap<String, Cluster.Member>();
+
+ private Set<String> deletedRegions = new HashSet<String>();
+
+ private Map<String, Cluster.Region> clusterRegionMap = new ConcurrentHashMap<String, Cluster.Region>();
+ private List<Cluster.Alert> alertsList = new ArrayList<Cluster.Alert>();
+
+ private CircularFifoBuffer totalBytesOnDiskTrend = new CircularFifoBuffer(
+ MAX_SAMPLE_SIZE);
+ private CircularFifoBuffer throughoutWritesTrend = new CircularFifoBuffer(
+ MAX_SAMPLE_SIZE);
+ private CircularFifoBuffer throughoutReadsTrend = new CircularFifoBuffer(
+ MAX_SAMPLE_SIZE);
+ private CircularFifoBuffer writePerSecTrend = new CircularFifoBuffer(
+ MAX_SAMPLE_SIZE);
+ private CircularFifoBuffer readPerSecTrend = new CircularFifoBuffer(
+ MAX_SAMPLE_SIZE);
+ private CircularFifoBuffer queriesPerSecTrend = new CircularFifoBuffer(
+ MAX_SAMPLE_SIZE);
+ private CircularFifoBuffer memoryUsageTrend = new CircularFifoBuffer(
+ MAX_SAMPLE_SIZE);
+ private CircularFifoBuffer garbageCollectionTrend = new CircularFifoBuffer(
+ MAX_SAMPLE_SIZE);
+ private long previousJVMPauseCount = 0L;
+
+ private HashMap<String, Boolean> wanInformation = new HashMap<String, Boolean>();
+ private Map<String, Cluster.Statement> clusterStatementMap = new ConcurrentHashMap<String, Cluster.Statement>();
+
+ public static final int CLUSTER_STAT_TOTAL_BYTES_ON_DISK = 0;
+ public static final int CLUSTER_STAT_THROUGHPUT_WRITES = 1;
+ public static final int CLUSTER_STAT_THROUGHPUT_READS = 2;
+ public static final int CLUSTER_STAT_WRITES_PER_SECOND = 3;
+ public static final int CLUSTER_STAT_READ_PER_SECOND = 4;
+ public static final int CLUSTER_STAT_QUERIES_PER_SECOND = 5;
+ public static final int CLUSTER_STAT_MEMORY_USAGE = 6;
+ public static final int CLUSTER_STAT_GARBAGE_COLLECTION = 7;
+
+ // end: fields defined in System MBean
+
+ // used for updating member's client data
+ public static long LAST_UPDATE_TIME = 0;
+
+ public int getStaleStatus() {
+ return this.stale;
+ }
+
+ private boolean stopUpdates = false;
+
+ private static final int MAX_HOSTS = 40;
+
+ private final List<String> hostNames = new ArrayList<String>();
+
+ private final ObjectMapper mapper = new ObjectMapper();
+
+ public Object[] getStatisticTrend(int trendId) {
+
+ Object[] returnArray = null;
+ switch (trendId) {
+ case CLUSTER_STAT_TOTAL_BYTES_ON_DISK:
+ synchronized (this.totalBytesOnDiskTrend) {
+ returnArray = this.totalBytesOnDiskTrend.toArray();
+ }
+
+ break;
+
+ case CLUSTER_STAT_THROUGHPUT_READS:
+ synchronized (this.throughoutReadsTrend) {
+ returnArray = this.throughoutReadsTrend.toArray();
+ }
+ break;
+
+ case CLUSTER_STAT_THROUGHPUT_WRITES:
+ synchronized (this.throughoutWritesTrend) {
+ returnArray = this.throughoutWritesTrend.toArray();
+ }
+ break;
+
+ case CLUSTER_STAT_WRITES_PER_SECOND:
+ synchronized (this.writePerSecTrend) {
+ returnArray = this.writePerSecTrend.toArray();
+ }
+ break;
+
+ case CLUSTER_STAT_READ_PER_SECOND:
+ synchronized (this.readPerSecTrend) {
+ returnArray = this.readPerSecTrend.toArray();
+ }
+ break;
+
+ case CLUSTER_STAT_QUERIES_PER_SECOND:
+ synchronized (this.queriesPerSecTrend) {
+ returnArray = this.queriesPerSecTrend.toArray();
+ }
+ break;
+
+ case CLUSTER_STAT_MEMORY_USAGE:
+ synchronized (this.memoryUsageTrend) {
+ returnArray = this.memoryUsageTrend.toArray();
+ }
+ break;
+
+ case CLUSTER_STAT_GARBAGE_COLLECTION:
+ synchronized (this.garbageCollectionTrend) {
+ returnArray = this.garbageCollectionTrend.toArray();
+ }
+ break;
+ }
+
+ return returnArray;
+ }
+
+ /**
+ * Member Inner Class
+ *
+ *
+ */
+ public static class Member {
+
+ // start: fields defined in MBean
+ private String gemfireVersion;
+ private boolean manager;
+ private int totalRegionCount;
+ private String host;
+ private String hostnameForClients;
+ private String bindAddress;
+ private long currentHeapSize;
+ private long maxHeapSize;
+ private int avgHeapUsage;
+ private long OffHeapFreeSize;
+ private long OffHeapUsedSize;
+ private long totalBytesOnDisk;
+ private String memberPort;
+
+ private double cpuUsage = 0.0d;
+ private double hostCpuUsage = 0.0d;
+ private long uptime;
+ private String name;
+ private double getsRate;
+ private double putsRate;
+ private boolean isCache;
+ private boolean isGateway;
+ private boolean isLocator;
+ private boolean isServer;
+ private double loadAverage;
+ private int numThreads;
+ private long totalFileDescriptorOpen;
+ private long garbageCollectionCount = 0L;
+ private double throughputWrites;
+ private double throughputReads;
+ private long totalDiskUsage;
+ private String queueBacklog;
+ private String id;
+ private long numSqlfireClients = 0;
+
+ private List<String> serverGroups = new ArrayList<String>();
+ private List<String> redundancyZones = new ArrayList<String>();
+
+ private CircularFifoBuffer cpuUsageSamples = new CircularFifoBuffer(
+ MAX_SAMPLE_SIZE);
+ private CircularFifoBuffer heapUsageSamples = new CircularFifoBuffer(
+ MAX_SAMPLE_SIZE);
+ private HashMap<String, Cluster.Region> memberRegions = new HashMap<String, Cluster.Region>();
+ private HashMap<String, Cluster.Client> memberClientsHMap = new HashMap<String, Cluster.Client>();
+ private CircularFifoBuffer totalBytesOnDiskSamples = new CircularFifoBuffer(
+ MAX_SAMPLE_SIZE);
+ private CircularFifoBuffer getsPerSecond = new CircularFifoBuffer(
+ MAX_SAMPLE_SIZE);
+ private CircularFifoBuffer putsPerSecond = new CircularFifoBuffer(
+ MAX_SAMPLE_SIZE);
+ private CircularFifoBuffer throughputWritesTrend = new CircularFifoBuffer(
+ MAX_SAMPLE_SIZE);
+ private CircularFifoBuffer throughputReadsTrend = new CircularFifoBuffer(
+ MAX_SAMPLE_SIZE);
+ private CircularFifoBuffer garbageCollectionSamples = new CircularFifoBuffer(
+ MAX_SAMPLE_SIZE);
+ private long previousJVMPauseCount = 0L;
+
+ private Cluster.GatewayReceiver gatewayReceiver = null;
+ private List<Cluster.GatewaySender> gatewaySenderList = new ArrayList<Cluster.GatewaySender>();
+ private List<Cluster.AsyncEventQueue> asyncEventQueueList = new ArrayList<Cluster.AsyncEventQueue>();
+ // end: fields defined in MBean
+
+ public static final int MEMBER_STAT_GARBAGE_COLLECTION = 0;
+ public static final int MEMBER_STAT_HEAP_USAGE_SAMPLE = 1;
+ public static final int MEMBER_STAT_CPU_USAGE_SAMPLE = 2;
+ public static final int MEMBER_STAT_GETS_PER_SECOND = 3;
+ public static final int MEMBER_STAT_PUTS_PER_SECOND = 4;
+ public static final int MEMBER_STAT_THROUGHPUT_WRITES = 5;
+ public static final int MEMBER_STAT_THROUGHPUT_READS = 6;
+
+ public Cluster.Region[] getMemberRegionsList() {
+ Cluster.Region[] memberReg = null;
+ synchronized (memberRegions) {
+ memberReg = new Cluster.Region[memberRegions.size()];
+ memberReg = memberRegions.values().toArray(memberReg);
+ }
+
+ return memberReg;
+ }
+
+ public Cluster.Client[] getMemberClients() {
+ Cluster.Client[] memberClients = null;
+ synchronized (memberClientsHMap) {
+ memberClients = new Cluster.Client[memberClientsHMap.size()];
+ memberClients = memberClientsHMap.values().toArray(memberClients);
+ }
+
+ return memberClients;
+ }
+
+ public Cluster.GatewaySender[] getMemberGatewaySenders() {
+ Cluster.GatewaySender[] memberGWS = null;
+ synchronized (gatewaySenderList) {
+ memberGWS = new Cluster.GatewaySender[gatewaySenderList.size()];
+ memberGWS = gatewaySenderList.toArray(memberGWS);
+ }
+ return memberGWS;
+ }
+
+ public Cluster.AsyncEventQueue[] getMemberAsyncEventQueueList() {
+ Cluster.AsyncEventQueue[] memberAEQ = null;
+ synchronized (asyncEventQueueList) {
+ memberAEQ = new Cluster.AsyncEventQueue[asyncEventQueueList.size()];
+ memberAEQ = asyncEventQueueList.toArray(memberAEQ);
+ }
+ return memberAEQ;
+ }
+
+ public Object[] getMemberStatisticTrend(int trendId) {
+ Object[] returnArray = null;
+ switch (trendId) {
+ case MEMBER_STAT_GARBAGE_COLLECTION:
+ synchronized (this.garbageCollectionSamples) {
+ returnArray = this.garbageCollectionSamples.toArray();
+ }
+
+ break;
+
+ case MEMBER_STAT_HEAP_USAGE_SAMPLE:
+ synchronized (this.heapUsageSamples) {
+ returnArray = this.heapUsageSamples.toArray();
+ }
+ break;
+
+ case MEMBER_STAT_CPU_USAGE_SAMPLE:
+ synchronized (this.cpuUsageSamples) {
+ returnArray = this.cpuUsageSamples.toArray();
+ }
+ break;
+
+ case MEMBER_STAT_GETS_PER_SECOND:
+ synchronized (this.getsPerSecond) {
+ returnArray = this.getsPerSecond.toArray();
+ }
+ break;
+
+ case MEMBER_STAT_PUTS_PER_SECOND:
+ synchronized (this.putsPerSecond) {
+ returnArray = this.putsPerSecond.toArray();
+ }
+ break;
+
+ case MEMBER_STAT_THROUGHPUT_WRITES:
+ synchronized (this.throughputWritesTrend) {
+ returnArray = this.throughputWritesTrend.toArray();
+ }
+ break;
+
+ case MEMBER_STAT_THROUGHPUT_READS:
+ synchronized (this.throughputReadsTrend) {
+ returnArray = this.throughputReadsTrend.toArray();
+ }
+ break;
+ }
+
+ return returnArray;
+ }
+
+ public String getGemfireVersion() {
+ return gemfireVersion;
+ }
+
+ public void setGemfireVersion(String gemfireVersion) {
+ this.gemfireVersion = gemfireVersion;
+ }
+
+ public String getMemberPort() {
+ return this.memberPort;
+ }
+
+ public void setMemberPort(String memberPort) {
+ this.memberPort = memberPort;
+ }
+
+ public double getThroughputWrites() {
+ return this.throughputWrites;
+ }
+
+ public void setThroughputWrites(double throughputWrites) {
+ this.throughputWrites = throughputWrites;
+ }
+
+ public double getThroughputReads() {
+ return this.throughputReads;
+ }
+
+ public void setThroughputReads(double throughputReads) {
+ this.throughputReads = throughputReads;
+ }
+
+ public long getTotalDiskUsage() {
+ return this.totalDiskUsage;
+ }
+
+ public void setTotalDiskUsage(long totalDiskUsage) {
+ this.totalDiskUsage = totalDiskUsage;
+ }
+
+ public String getId() {
+ return this.id;
+ }
+
+ public String getName() {
+ return this.name;
+ }
+
+ public double getLoadAverage() {
+ return this.loadAverage;
+ }
+
+ public void setLoadAverage(Double loadAverage) {
+ this.loadAverage = loadAverage;
+ }
+
+ public String getHost() {
+ return this.host;
+ }
+
+ public String getHostnameForClients() {
+ if(StringUtils.isNotNullNotEmptyNotWhiteSpace(hostnameForClients))
+ return this.hostnameForClients;
+ else if(StringUtils.isNotNullNotEmptyNotWhiteSpace(bindAddress))
+ return this.bindAddress;
+ return null;
+ }
+
+ public long getUptime() {
+ return this.uptime;
+ }
+
+ public String getQueueBacklog() {
+ return this.queueBacklog;
+ }
+
+ public HashMap<String, Cluster.Region> getMemberRegions() {
+ return this.memberRegions;
+ }
+
+ public void setMemberRegions(HashMap<String, Cluster.Region> memberRegions) {
+ this.memberRegions = memberRegions;
+ }
+
+ public long getCurrentHeapSize() {
+ return this.currentHeapSize;
+ }
+
+ public void setCurrentHeapSize(long currentHeapSize) {
+ this.currentHeapSize = currentHeapSize;
+ }
+
+ public long getMaxHeapSize() {
+ return this.maxHeapSize;
+ }
+
+ public void setMaxHeapSize(long maxHeapSize) {
+ this.maxHeapSize = maxHeapSize;
+ }
+
+ public boolean isManager() {
+ return this.manager;
+ }
+
+ public void setManager(boolean manager) {
+ this.manager = manager;
+ }
+
+ public int getAvgHeapUsage() {
+ return this.avgHeapUsage;
+ }
+
+ public void setAvgHeapUsage(int avgHeapUsage) {
+ this.avgHeapUsage = avgHeapUsage;
+ }
+
+ public long getOffHeapFreeSize() {
+ return OffHeapFreeSize;
+ }
+
+ public void setOffHeapFreeSize(long offHeapFreeSize) {
+ this.OffHeapFreeSize = offHeapFreeSize;
+ }
+
+ public long getOffHeapUsedSize() {
+ return OffHeapUsedSize;
+ }
+
+ public void setOffHeapUsedSize(long offHeapUsedSize) {
+ this.OffHeapUsedSize = offHeapUsedSize;
+ }
+
+ public void setId(String id) {
+ this.id = id;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public void setHost(String host) {
+ this.host = host;
+ }
+
+ public void setHostnameForClients(String hostnameForClients) {
+ this.hostnameForClients = hostnameForClients;
+ }
+
+ public void setBindAddress(String bindAddress){
+ this.bindAddress = bindAddress;
+ }
+
+ public void setUptime(long uptime) {
+ this.uptime = uptime;
+ }
+
+ public void setQueueBacklog(String queueBacklog) {
+ this.queueBacklog = queueBacklog;
+ }
+
+ public int getTotalRegionCount() {
+ return this.totalRegionCount;
+ }
+
+ public void setTotalRegionCount(int totalRegionCount) {
+ this.totalRegionCount = totalRegionCount;
+ }
+
+ public long getTotalBytesOnDisk() {
+ return this.totalBytesOnDisk;
+ }
+
+ public void setTotalBytesOnDisk(long totalBytesOnDisk) {
+ this.totalBytesOnDisk = totalBytesOnDisk;
+ }
+
+ public double getCpuUsage() {
+ return this.cpuUsage;
+ }
+
+ public void setCpuUsage(double cpuUsage) {
+ this.cpuUsage = cpuUsage;
+ }
+
+ public double getHostCpuUsage() {
+ return this.hostCpuUsage;
+ }
+
+ public void setHostCpuUsage(double hostCpuUsage) {
+ this.hostCpuUsage = hostCpuUsage;
+ }
+
+ public double getGetsRate() {
+ return this.getsRate;
+ }
+
+ public void setGetsRate(double getsRate) {
+ this.getsRate = getsRate;
+ }
+
+ public double getPutsRate() {
+ return this.putsRate;
+ }
+
+ public void setPutsRate(double putsRate) {
+ this.putsRate = putsRate;
+ }
+
+ public HashMap<String, Cluster.Client> getMemberClientsHMap() {
+ return this.memberClientsHMap;
+ }
+
+ public void setMemberClientsHMap(
+ HashMap<String, Cluster.Client> memberClientsHMap) {
+ this.memberClientsHMap = memberClientsHMap;
+ }
+
+ public boolean isCache() {
+ return this.isCache;
+ }
+
+ public void setCache(boolean isCache) {
+ this.isCache = isCache;
+ }
+
+ public boolean isGateway() {
+ return this.isGateway;
+ }
+
+ public void setGateway(boolean isGateway) {
+ this.isGateway = isGateway;
+ }
+
+ public int getNumThreads() {
+ return this.numThreads;
+ }
+
+ public void setNumThreads(int numThreads) {
+ this.numThreads = numThreads;
+ }
+
+ public long getTotalFileDescriptorOpen() {
+ return this.totalFileDescriptorOpen;
+ }
+
+ public void setTotalFileDescriptorOpen(long totalFileDescriptorOpen) {
+ this.totalFileDescriptorOpen = totalFileDescriptorOpen;
+ }
+
+ public long getGarbageCollectionCount() {
+ return this.garbageCollectionCount;
+ }
+
+ public void setGarbageCollectionCount(long garbageCollectionCount) {
+ this.garbageCollectionCount = garbageCollectionCount;
+ }
+
+ public boolean isLocator() {
+ return this.isLocator;
+ }
+
+ public void setLocator(boolean isLocator) {
+ this.isLocator = isLocator;
+ }
+
+ public Cluster.GatewayReceiver getGatewayReceiver() {
+ return this.gatewayReceiver;
+ }
+
+ public void setGatewayReceiver(Cluster.GatewayReceiver gatewayReceiver) {
+ this.gatewayReceiver = gatewayReceiver;
+ }
+
+ public List<Cluster.GatewaySender> getGatewaySenderList() {
+ return this.gatewaySenderList;
+ }
+
+ public void setGatewaySenderList(
+ List<Cluster.GatewaySender> gatewaySenderList) {
+ this.gatewaySenderList = gatewaySenderList;
+ }
+
+ public List<Cluster.AsyncEventQueue> getAsyncEventQueueList() {
+ return this.asyncEventQueueList;
+ }
+
+ public void setAsyncEventQueueList(
+ List<Cluster.AsyncEventQueue> asyncEventQueueList) {
+ this.asyncEventQueueList = asyncEventQueueList;
+ }
+
+ public boolean isServer() {
+ return this.isServer;
+ }
+
+ public void setServer(boolean isServer) {
+ this.isServer = isServer;
+ }
+
+ public List<String> getServerGroups() {
+ return this.serverGroups;
+ }
+
+ public void setServerGroups(List<String> serverGroups) {
+ this.serverGroups = serverGroups;
+ }
+
+ public List<String> getRedundancyZones() {
+ return this.redundancyZones;
+ }
+
+ public void setRedundancyZones(List<String> redundancyZones) {
+ this.redundancyZones = redundancyZones;
+ }
+
+ public CircularFifoBuffer getCpuUsageSamples() {
+ return this.cpuUsageSamples;
+ }
+
+ public void setCpuUsageSamples(CircularFifoBuffer cpuUsageSamples) {
+ this.cpuUsageSamples = cpuUsageSamples;
+ }
+
+ public CircularFifoBuffer getHeapUsageSamples() {
+ return this.heapUsageSamples;
+ }
+
+ public void setHeapUsageSamples(CircularFifoBuffer heapUsageSamples) {
+ this.heapUsageSamples = heapUsageSamples;
+ }
+
+ public CircularFifoBuffer getTotalBytesOnDiskSamples() {
+ return this.totalBytesOnDiskSamples;
+ }
+
+ public void setTotalBytesOnDiskSamples(
+ CircularFifoBuffer totalBytesOnDiskSamples) {
+ this.totalBytesOnDiskSamples = totalBytesOnDiskSamples;
+ }
+
+ public CircularFifoBuffer getGetsPerSecond() {
+ return this.getsPerSecond;
+ }
+
+ public void setGetsPerSecond(CircularFifoBuffer getsPerSecond) {
+ this.getsPerSecond = getsPerSecond;
+ }
+
+ public CircularFifoBuffer getPutsPerSecond() {
+ return this.putsPerSecond;
+ }
+
+ public void setPutsPerSecond(CircularFifoBuffer putsPerSecond) {
+ this.putsPerSecond = putsPerSecond;
+ }
+
+ public CircularFifoBuffer getThroughputWritesTrend() {
+ return this.throughputWritesTrend;
+ }
+
+ public void setThroughputWritesTrend(
+ CircularFifoBuffer throughputWritesTrend) {
+ this.throughputWritesTrend = throughputWritesTrend;
+ }
+
+ public CircularFifoBuffer getThroughputReadsTrend() {
+ return this.throughputReadsTrend;
+ }
+
+ public void setThroughputReadsTrend(CircularFifoBuffer throughputReadsTrend) {
+ this.throughputReadsTrend = throughputReadsTrend;
+ }
+
+ public CircularFifoBuffer getGarbageCollectionSamples() {
+ return this.garbageCollectionSamples;
+ }
+
+ public void setGarbageCollectionSamples(
+ CircularFifoBuffer garbageCollectionSamples) {
+ this.garbageCollectionSamples = garbageCollectionSamples;
+ }
+
+ public long getPreviousJVMPauseCount() {
+ return this.previousJVMPauseCount;
+ }
+
+ public void setPreviousJVMPauseCount(long previousJVMPauseCount) {
+ this.previousJVMPauseCount = previousJVMPauseCount;
+ }
+
+ public long getNumSqlfireClients() {
+ return numSqlfireClients;
+ }
+
+ public void setNumSqlfireClients(long numSqlfireClients) {
+ this.numSqlfireClients = numSqlfireClients;
+ }
+
+ public void updateMemberClientsHMap(
+ HashMap<String, Cluster.Client> memberClientsHM) {
+
+ if (Cluster.LAST_UPDATE_TIME == 0) {
+ Cluster.LAST_UPDATE_TIME = System.nanoTime();
+ }
+
+ long systemNanoTime = System.nanoTime();
+
+ for (Map.Entry<String, Cluster.Client> entry : memberClientsHM.entrySet()) {
+ String clientId = entry.getKey();
+ Cluster.Client client = entry.getValue();
+
+ if (memberClientsHMap.get(clientId) != null) {
+ Client existingClient = memberClientsHMap.get(clientId);
+ Client updatedClient = memberClientsHM.get(clientId);
+
+ existingClient.setConnected(updatedClient.isConnected());
+ existingClient.setGets(updatedClient.getGets());
+ existingClient.setPuts(updatedClient.getPuts());
+ existingClient.setCpus(updatedClient.getCpus());
+ existingClient.setQueueSize(updatedClient.getQueueSize());
+ existingClient.setStatus(updatedClient.getStatus());
+ existingClient.setThreads(updatedClient.getThreads());
+ existingClient.setClientCQCount(updatedClient.getClientCQCount());
+ existingClient.setSubscriptionEnabled(updatedClient.isSubscriptionEnabled());
+ long elapsedTime = updatedClient.getUptime()
+ - existingClient.getUptime();
+ existingClient.setUptime(updatedClient.getUptime());
+
+ // set cpu usage
+ long lastCPUTime = 0;
+ lastCPUTime = existingClient.getProcessCpuTime();
+ long currCPUTime = 0;
+ currCPUTime = updatedClient.getProcessCpuTime();
+
+ double newCPUTime = (double) (currCPUTime - lastCPUTime)
+ / (elapsedTime * 1000000000);
+
+ double newCPUUsage = 0;
+ int availableCpus = updatedClient.getCpus();
+ if (availableCpus > 0) {
+ newCPUUsage = newCPUTime / availableCpus;
+ }
+
+ existingClient.setCpuUsage(newCPUUsage);
+ existingClient.setProcessCpuTime(currCPUTime);
+
+ } else {
+ // Add client to clients list
+ memberClientsHMap.put(clientId, client);
+ }
+
+ }
+
+ // Remove unwanted entries from clients list
+ HashMap<String, Cluster.Client> memberClientsHMapNew = new HashMap<String, Cluster.Client>();
+ for (Map.Entry<String, Cluster.Client> entry : memberClientsHMap
+ .entrySet()) {
+ String clientId = entry.getKey();
+ if (memberClientsHM.get(clientId) != null) {
+ memberClientsHMapNew.put(clientId, memberClientsHMap.get(clientId));
+ }
+ }
+ // replace existing memberClientsHMap by memberClientsHMapNew
+ this.setMemberClientsHMap(memberClientsHMapNew);
+
+ // update last update time
+ Cluster.LAST_UPDATE_TIME = systemNanoTime;
+
+ }
+
+ }
+
+ /**
+ * Member Inner Class
+ *
+ *
+ */
+ public static class Statement {
+
+ private String queryDefn;
+ private long numTimesCompiled;
+ private long numExecution;
+ private long numExecutionsInProgress;
+ private long numTimesGlobalIndexLookup;
+ private long numRowsModified;
+ private long parseTime;
+ private long bindTime;
+ private long optimizeTime;
+ private long routingInfoTime;
+ private long generateTime;
+ private long totalCompilationTime;
+ private long executionTime;
+ private long projectionTime;
+ private long totalExecutionTime;
+ private long rowsModificationTime;
+ private long qNNumRowsSeen;
+ private long qNMsgSendTime;
+ private long qNMsgSerTime;
+ private long qNRespDeSerTime;
+
+ public static String[] getGridColumnNames() {
+ String[] colNames = new String[] {
+ PulseConstants.MBEAN_COLNAME_QUERYDEFINITION,
+ PulseConstants.MBEAN_COLNAME_NUMEXECUTION,
+ PulseConstants.MBEAN_COLNAME_TOTALEXECUTIONTIME,
+ PulseConstants.MBEAN_COLNAME_NUMEXECUTIONSINPROGRESS,
+ PulseConstants.MBEAN_COLNAME_NUMTIMESCOMPILED,
+ PulseConstants.MBEAN_COLNAME_NUMTIMESGLOBALINDEXLOOKUP,
+ PulseConstants.MBEAN_COLNAME_NUMROWSMODIFIED,
+ PulseConstants.MBEAN_COLNAME_PARSETIME,
+ PulseConstants.MBEAN_COLNAME_BINDTIME,
+ PulseConstants.MBEAN_COLNAME_OPTIMIZETIME,
+ PulseConstants.MBEAN_COLNAME_ROUTINGINFOTIME,
+ PulseConstants.MBEAN_COLNAME_GENERATETIME,
+ PulseConstants.MBEAN_COLNAME_TOTALCOMPILATIONTIME,
+ PulseConstants.MBEAN_COLNAME_EXECUTIONTIME,
+ PulseConstants.MBEAN_COLNAME_PROJECTIONTIME,
+ PulseConstants.MBEAN_COLNAME_ROWSMODIFICATIONTIME,
+ PulseConstants.MBEAN_COLNAME_QNNUMROWSSEEN,
+ PulseConstants.MBEAN_COLNAME_QNMSGSENDTIME,
+ PulseConstants.MBEAN_COLNAME_QNMSGSERTIME,
+ PulseConstants.MBEAN_COLNAME_QNRESPDESERTIME };
+ return colNames;
+ }
+
+ public static String[] getGridColumnAttributes() {
+ String[] colAttributes = new String[] {
+ PulseConstants.MBEAN_ATTRIBUTE_QUERYDEFINITION,
+ PulseConstants.MBEAN_ATTRIBUTE_NUMEXECUTION,
+ PulseConstants.MBEAN_ATTRIBUTE_TOTALEXECUTIONTIME,
+ PulseConstants.MBEAN_ATTRIBUTE_NUMEXECUTIONSINPROGRESS,
+ PulseConstants.MBEAN_ATTRIBUTE_NUMTIMESCOMPILED,
+ PulseConstants.MBEAN_ATTRIBUTE_NUMTIMESGLOBALINDEXLOOKUP,
+ PulseConstants.MBEAN_ATTRIBUTE_NUMROWSMODIFIED,
+ PulseConstants.MBEAN_ATTRIBUTE_PARSETIME,
+ PulseConstants.MBEAN_ATTRIBUTE_BINDTIME,
+ PulseConstants.MBEAN_ATTRIBUTE_OPTIMIZETIME,
+ PulseConstants.MBEAN_ATTRIBUTE_ROUTINGINFOTIME,
+ PulseConstants.MBEAN_ATTRIBUTE_GENERATETIME,
+ PulseConstants.MBEAN_ATTRIBUTE_TOTALCOMPILATIONTIME,
+ PulseConstants.MBEAN_ATTRIBUTE_EXECUTIONTIME,
+ PulseConstants.MBEAN_ATTRIBUTE_PROJECTIONTIME,
+
+ PulseConstants.MBEAN_ATTRIBUTE_ROWSMODIFICATIONTIME,
+ PulseConstants.MBEAN_ATTRIBUTE_QNNUMROWSSEEN,
+ PulseConstants.MBEAN_ATTRIBUTE_QNMSGSENDTIME,
+ PulseConstants.MBEAN_ATTRIBUTE_QNMSGSERTIME,
+ PulseConstants.MBEAN_ATTRIBUTE_QNRESPDESERTIME };
+ return colAttributes;
+ }
+
+ public static int[] getGridColumnWidths() {
+ int[] colWidths = new int[] { 300, 150, 160, 180, 150, 200, 150, 130, 130,
+ 160, 140, 180, 170, 160, 130, 190, 170, 170, 170, 200 };
+ return colWidths;
+ }
+
+ /**
+ * @return the numTimesCompiled
+ */
+ public String getQueryDefinition() {
+ return queryDefn;
+ }
+
+ /**
+ * @param queryDefn
+ * the query to set
+ */
+ public void setQueryDefinition(String queryDefn) {
+ this.queryDefn = queryDefn;
+ }
+
+ /**
+ * @return the numTimesCompiled
+ */
+ public long getNumTimesCompiled() {
+ return numTimesCompiled;
+ }
+
+ /**
+ * @param numTimesCompiled
+ * the numTimesCompiled to set
+ */
+ public void setNumTimesCompiled(long numTimesCompiled) {
+ this.numTimesCompiled = numTimesCompiled;
+ }
+
+ /**
+ * @return the numExecution
+ */
+ public long getNumExecution() {
+ return numExecution;
+ }
+
+ /**
+ * @param numExecution
+ * the numExecution to set
+ */
+ public void setNumExecution(long numExecution) {
+ this.numExecution = numExecution;
+ }
+
+ /**
+ * @return the numExecutionsInProgress
+ */
+ public long getNumExecutionsInProgress() {
+ return numExecutionsInProgress;
+ }
+
+ /**
+ * @param numExecutionsInProgress
+ * the numExecutionsInProgress to set
+ */
+ public void setNumExecutionsInProgress(long numExecutionsInProgress) {
+ this.numExecutionsInProgress = numExecutionsInProgress;
+ }
+
+ /**
+ * @return the numTimesGlobalIndexLookup
+ */
+ public long getNumTimesGlobalIndexLookup() {
+ return numTimesGlobalIndexLookup;
+ }
+
+ /**
+ * @param numTimesGlobalIndexLookup
+ * the numTimesGlobalIndexLookup to set
+ */
+ public void setNumTimesGlobalIndexLookup(long numTimesGlobalIndexLookup) {
+ this.numTimesGlobalIndexLookup = numTimesGlobalIndexLookup;
+ }
+
+ /**
+ * @return the numRowsModified
+ */
+ public long getNumRowsModified() {
+ return numRowsModified;
+ }
+
+ /**
+ * @param numRowsModified
+ * the numRowsModified to set
+ */
+ public void setNumRowsModified(long numRowsModified) {
+ this.numRowsModified = numRowsModified;
+ }
+
+ /**
+ * @return the parseTime
+ */
+ public long getParseTime() {
+ return parseTime;
+ }
+
+ /**
+ * @param parseTime
+ * the parseTime to set
+ */
+ public void setParseTime(long parseTime) {
+ this.parseTime = parseTime;
+ }
+
+ /**
+ * @return the bindTime
+ */
+ public long getBindTime() {
+ return bindTime;
+ }
+
+ /**
+ * @param bindTime
+ * the bindTime to set
+ */
+ public void setBindTime(long bindTime) {
+ this.bindTime = bindTime;
+ }
+
+ /**
+ * @return the optimizeTime
+ */
+ public long getOptimizeTime() {
+ return optimizeTime;
+ }
+
+ /**
+ * @param optimizeTime
+ * the optimizeTime to set
+ */
+ public void setOptimizeTime(long optimizeTime) {
+ this.optimizeTime = optimizeTime;
+ }
+
+ /**
+ * @return the routingInfoTime
+ */
+ public long getRoutingInfoTime() {
+ return routingInfoTime;
+ }
+
+ /**
+ * @param routingInfoTime
+ * the routingInfoTime to set
+ */
+ public void setRoutingInfoTime(long routingInfoTime) {
+ this.routingInfoTime = routingInfoTime;
+ }
+
+ /**
+ * @return the generateTime
+ */
+ public long getGenerateTime() {
+ return generateTime;
+ }
+
+ /**
+ * @param generateTime
+ * the generateTime to set
+ */
+ public void setGenerateTime(long generateTime) {
+ this.generateTime = generateTime;
+ }
+
+ /**
+ * @return the totalCompilationTime
+ */
+ public long getTotalCompilationTime() {
+ return totalCompilationTime;
+ }
+
+ /**
+ * @param totalCompilationTime
+ * the totalCompilationTime to set
+ */
+ public void setTotalCompilationTime(long totalCompilationTime) {
+ this.totalCompilationTime = totalCompilationTime;
+ }
+
+ /**
+ * @return the executionTime
+ */
+ public long getExecutionTime() {
+ return executionTime;
+ }
+
+ /**
+ * @param executionTime
+ * the executionTime to set
+ */
+ public void setExecutionTime(long executionTime) {
+ this.executionTime = executionTime;
+ }
+
+ /**
+ * @return the projectionTime
+ */
+ public long getProjectionTime() {
+ return projectionTime;
+ }
+
+ /**
+ * @param projectionTime
+ * the projectionTime to set
+ */
+ public void setProjectionTime(long projectionTime) {
+ this.projectionTime = projectionTime;
+ }
+
+ /**
+ * @return the totalExecutionTime
+ */
+ public long getTotalExecutionTime() {
+ return totalExecutionTime;
+ }
+
+ /**
+ * @param totalExecutionTime
+ * the totalExecutionTime to set
+ */
+ public void setTotalExecutionTime(long totalExecutionTime) {
+ this.totalExecutionTime = totalExecutionTime;
+ }
+
+ /**
+ * @return the rowsModificationTime
+ */
+ public long getRowsModificationTime() {
+ return rowsModificationTime;
+ }
+
+ /**
+ * @param rowsModificationTime
+ * the rowsModificationTime to set
+ */
+ public void setRowsModificationTime(long rowsModificationTime) {
+ this.rowsModificationTime = rowsModificationTime;
+ }
+
+ /**
+ * @return the qNNumRowsSeen
+ */
+ public long getqNNumRowsSeen() {
+ return qNNumRowsSeen;
+ }
+
+ /**
+ * @param qNNumRowsSeen
+ * the qNNumRowsSeen to set
+ */
+ public void setqNNumRowsSeen(long qNNumRowsSeen) {
+ this.qNNumRowsSeen = qNNumRowsSeen;
+ }
+
+ /**
+ * @return the qNMsgSendTime
+ */
+ public long getqNMsgSendTime() {
+ return qNMsgSendTime;
+ }
+
+ /**
+ * @param qNMsgSendTime
+ * the qNMsgSendTime to set
+ */
+ public void setqNMsgSendTime(long qNMsgSendTime) {
+ this.qNMsgSendTime = qNMsgSendTime;
+ }
+
+ /**
+ * @return the qNMsgSerTime
+ */
+ public long getqNMsgSerTime() {
+ return qNMsgSerTime;
+ }
+
+ /**
+ * @param qNMsgSerTime
+ * the qNMsgSerTime to set
+ */
+ public void setqNMsgSerTime(long qNMsgSerTime) {
+ this.qNMsgSerTime = qNMsgSerTime;
+ }
+
+ /**
+ * @return the qNRespDeSerTime
+ */
+ public long getqNRespDeSerTime() {
+ return qNRespDeSerTime;
+ }
+
+ /**
+ * @param qNRespDeSerTime
+ * the qNRespDeSerTime to set
+ */
+ public void setqNRespDeSerTime(long qNRespDeSerTime) {
+ this.qNRespDeSerTime = qNRespDeSerTime;
+ }
+ }
+
+ public static class RegionOnMember {
+
+ public static final int REGION_ON_MEMBER_STAT_GETS_PER_SEC_TREND = 0;
+ public static final int REGION_ON_MEMBER_STAT_PUTS_PER_SEC_TREND = 1;
+ public static final int REGION_ON_MEMBER_STAT_DISK_READS_PER_SEC_TREND = 3;
+ public static final int REGION_ON_MEMBER_STAT_DISK_WRITES_PER_SEC_TREND = 4;
+
+ private String regionFullPath;
+ private String memberName;
+ private long entrySize;
+ private long entryCount;
+ private double getsRate;
+ private double putsRate;
+ private double diskGetsRate;
+ private double diskPutsRate;
+ private int localMaxMemory;
+
+ private CircularFifoBuffer getsPerSecTrend = new CircularFifoBuffer(
+ MAX_SAMPLE_SIZE);
+ private CircularFifoBuffer putsPerSecTrend = new CircularFifoBuffer(
+ MAX_SAMPLE_SIZE);
+ private CircularFifoBuffer diskReadsPerSecTrend = new CircularFifoBuffer(
+ MAX_SAMPLE_SIZE);
+ private CircularFifoBuffer diskWritesPerSecTrend = new CircularFifoBuffer(
+ MAX_SAMPLE_SIZE);
+
+ /**
+ * @return the entrySize
+ */
+ public long getEntrySize() {
+ return entrySize;
+ }
+
+ /**
+ * @param entrySize the entrySize to set
+ */
+ public void setEntrySize(long entrySize) {
+ this.entrySize = entrySize;
+ }
+
+ /**
+ * @return the entryCount
+ */
+ public long getEntryCount() {
+ return entryCount;
+ }
+
+ /**
+ * @param entryCount the entryCount to set
+ */
+ public void setEntryCount(long entryCount) {
+ this.entryCount = entryCount;
+ }
+
+ /**
+ * @return the putsRate
+ */
+ public double getPutsRate() {
+ return putsRate;
+ }
+
+ /**
+ * @param putsRate the putsRate to set
+ */
+ public void setPutsRate(double putsRate) {
+ this.putsRate = putsRate;
+ }
+
+ /**
+ * @return the getsRate
+ */
+ public double getGetsRate() {
+ return getsRate;
+ }
+
+ /**
+ * @param getsRate the getsRate to set
+ */
+ public void setGetsRate(double getsRate) {
+ this.getsRate = getsRate;
+ }
+
+ /**
+ * @return the diskGetsRate
+ */
+ public double getDiskGetsRate() {
+ return diskGetsRate;
+ }
+
+ /**
+ * @param diskGetsRate the diskGetsRate to set
+ */
+ public void setDiskGetsRate(double diskGetsRate) {
+ this.diskGetsRate = diskGetsRate;
+ }
+
+ /**
+ * @return the diskPutsRate
+ */
+ public double getDiskPutsRate() {
+ return diskPutsRate;
+ }
+
+ /**
+ * @param diskPutsRate the diskPutsRate to set
+ */
+ public void setDiskPutsRate(double diskPutsRate) {
+ this.diskPutsRate = diskPutsRate;
+ }
+
+ /**
+ * @return the local maximum memory
+ */
+ public int getLocalMaxMemory() {
+ return this.localMaxMemory;
+ }
+
+ /**
+ * @param localMaxMemory
+ */
+ public void setLocalMaxMemory(int localMaxMemory) {
+ this.localMaxMemory = localMaxMemory;
+ }
+
+ /**
+ * @return the getsPerSecTrend
+ */
+ public CircularFifoBuffer getGetsPerSecTrend() {
+ return getsPerSecTrend;
+ }
+
+ /**
+ * @param getsPerSecTrend the getsPerSecTrend to set
+ */
+ public void setGetsPerSecTrend(CircularFifoBuffer getsPerSecTrend) {
+ this.getsPerSecTrend = getsPerSecTrend;
+ }
+
+ /**
+ * @return the putsPerSecTrend
+ */
+ public CircularFifoBuffer getPutsPerSecTrend() {
+ return putsPerSecTrend;
+ }
+
+ /**
+ * @param putsPerSecTrend the putsPerSecTrend to set
+ */
+ public void setPutsPerSecTrend(CircularFifoBuffer putsPerSecTrend) {
+ this.putsPerSecTrend = putsPerSecTrend;
+ }
+
+ /**
+ * @return the diskReadsPerSecTrend
+ */
+ public CircularFifoBuffer getDiskReadsPerSecTrend() {
+ return diskReadsPerSecTrend;
+ }
+
+ /**
+ * @param diskReadsPerSecTrend the diskReadsPerSecTrend to set
+ */
+ public void setDiskReadsPerSecTrend(CircularFifoBuffer diskReadsPerSecTrend) {
+ this.diskReadsPerSecTrend = diskReadsPerSecTrend;
+ }
+
+ /**
+ * @return the diskWritesPerSecTrend
+ */
+ public CircularFifoBuffer getDiskWritesPerSecTrend() {
+ return diskWritesPerSecTrend;
+ }
+
+ /**
+ * @param diskWritesPerSecTrend the diskWritesPerSecTrend to set
+ */
+ public void setDiskWritesPerSecTrend(CircularFifoBuffer diskWritesPerSecTrend) {
+ this.diskWritesPerSecTrend = diskWritesPerSecTrend;
+ }
+
+ public Object[] getRegionOnMemberStatisticTrend(int trendId) {
+
+ Object[] returnArray = null;
+ switch (trendId) {
+ case REGION_ON_MEMBER_STAT_GETS_PER_SEC_TREND:
+ synchronized (this.getsPerSecTrend) {
+ returnArray = this.getsPerSecTrend.toArray();
+ }
+ break;
+
+ case REGION_ON_MEMBER_STAT_PUTS_PER_SEC_TREND:
+ synchronized (this.putsPerSecTrend) {
+ returnArray = this.putsPerSecTrend.toArray();
+ }
+ break;
+
+ case REGION_ON_MEMBER_STAT_DISK_READS_PER_SEC_TREND:
+ synchronized (this.diskReadsPerSecTrend) {
+ returnArray = this.diskReadsPerSecTrend.toArray();
+ }
+ break;
+
+ case REGION_ON_MEMBER_STAT_DISK_WRITES_PER_SEC_TREND:
+ synchronized (this.diskWritesPerSecTrend) {
+ returnArray = this.diskWritesPerSecTrend.toArray();
+ }
+ break;
+ }
+
+ return returnArray;
+ }
+
+ /**
+ * @return the regionFullPath
+ */
+ public String getRegionFullPath() {
+ return regionFullPath;
+ }
+
+ /**
+ * @param regionFullPath the regionFullPath to set
+ */
+ public void setRegionFullPath(String regionFullPath) {
+ this.regionFullPath = regionFullPath;
+ }
+
+ /**
+ * @return the memberName
+ */
+ public String getMemberName() {
+ return memberName;
+ }
+
+ /**
+ * @param memberName the memberName to set
+ */
+ public void setMemberName(String memberName) {
+ this.memberName = memberName;
+ }
+ }
+
+ /**
+ * Region Inner Class
+ *
+ *
+ */
+ public static class Region {
+ // start: fields defined in MBean
+ private String fullPath;
+ private double diskReadsRate;
+ private double diskWritesRate;
+ private double getsRate;
+ private double putsRate;
+ private double lruEvictionRate;
+ private String regionType;
+ private long systemRegionEntryCount;
+ private int memberCount;
+ private String name;
+ private boolean persistentEnabled;
+ private long entrySize;
+ private boolean wanEnabled;
+ private int emptyNode;
+ private long diskUsage;
+ private String scope;
+ private String diskStoreName;
+ private boolean diskSynchronous;
+ private boolean enableOffHeapMemory;
+ private String compressionCodec = "";
+
+ private List<String> memberName = new ArrayList<String>();
+ private List<RegionOnMember> regionOnMembers = new ArrayList<RegionOnMember>();
+ private CircularFifoBuffer getsPerSecTrend = new CircularFifoBuffer(
+ MAX_SAMPLE_SIZE);
+ private CircularFifoBuffer putsPerSecTrend = new CircularFifoBuffer(
+ MAX_SAMPLE_SIZE);
+ private CircularFifoBuffer diskReadsPerSecTrend = new CircularFifoBuffer(
+ MAX_SAMPLE_SIZE);
+ private CircularFifoBuffer diskWritesPerSecTrend = new CircularFifoBuffer(
+ MAX_SAMPLE_SIZE);
+
+ public static final int REGION_STAT_GETS_PER_SEC_TREND = 0;
+ public static final int REGION_STAT_PUTS_PER_SEC_TREND = 1;
+ public static final int REGION_STAT_DISK_READS_PER_SEC_TREND = 3;
+ public static final int REGION_STAT_DISK_WRITES_PER_SEC_TREND = 4;
+
+ // end: fields defined in MBean
+
+ public Object[] getRegionStatisticTrend(int trendId) {
+
+ Object[] returnArray = null;
+ switch (trendId) {
+ case REGION_STAT_GETS_PER_SEC_TREND:
+ synchronized (this.getsPerSecTrend) {
+ returnArray = this.getsPerSecTrend.toArray();
+ }
+ break;
+
+ case REGION_STAT_PUTS_PER_SEC_TREND:
+ synchronized (this.putsPerSecTrend) {
+ returnArray = this.putsPerSecTrend.toArray();
+ }
+ break;
+
+ case REGION_STAT_DISK_READS_PER_SEC_TREND:
+ synchronized (this.diskReadsPerSecTrend) {
+ returnArray = this.diskReadsPerSecTrend.toArray();
+ }
+ break;
+
+ case REGION_STAT_DISK_WRITES_PER_SEC_TREND:
+ synchronized (this.diskWritesPerSecTrend) {
+ returnArray = this.diskWritesPerSecTrend.toArray();
+ }
+ break;
+ }
+
+ return returnArray;
+ }
+
+ public boolean isDiskSynchronous() {
+ return this.diskSynchronous;
+ }
+
+ public void setDiskSynchronous(boolean diskSynchronous) {
+ this.diskSynchronous = diskSynchronous;
+ }
+
+ public String getDiskStoreName() {
+ return this.diskStoreName;
+ }
+
+ public void setDiskStoreName(String diskStoreName) {
+ this.diskStoreName = diskStoreName;
+ }
+
+ public String getScope() {
+ return this.scope;
+ }
+
+ public void setScope(String scope) {
+ this.scope = scope;
+ }
+
+ public int getEmptyNode() {
+ return this.emptyNode;
+ }
+
+ public void setEmptyNode(int emptyNode) {
+ this.emptyNode = emptyNode;
+ }
+
+ public long getDiskUsage() {
+ return this.diskUsage;
+ }
+
+ public void setDiskUsage(long diskUsage) {
+ this.diskUsage = diskUsage;
+ }
+
+ public void setEntrySize(long entrySize) {
+ this.entrySize = entrySize;
+ }
+
+ public boolean getWanEnabled() {
+ return this.wanEnabled;
+ }
+
+ public void setWanEnabled(boolean wanEnabled) {
+ this.wanEnabled = wanEnabled;
+ }
+
+ public boolean getPersistentEnabled() {
+ return this.persistentEnabled;
+ }
+
+ public void setPersistentEnabled(boolean persistentEnabled) {
+ this.persistentEnabled = persistentEnabled;
+ }
+
+ public String getName() {
+ return this.name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public long getEntrySize() {
+ return this.entrySize;
+ }
+
+ public List<String> getMemberName() {
+ return this.memberName;
+ }
+
+ public void setMemberName(List<String> memberName) {
+ this.memberName = memberName;
+ }
+
+ public String getFullPath() {
+ return this.fullPath;
+ }
+
+ public void setFullPath(String fullPath) {
+ this.fullPath = fullPath;
+ }
+
+ public double getDiskReadsRate() {
+ return this.diskReadsRate;
+ }
+
+ public void setDiskReadsRate(double diskReadsRate) {
+ this.diskReadsRate = diskReadsRate;
+ }
+
+ public double getDiskWritesRate() {
+ return this.diskWritesRate;
+ }
+
+ public void setDiskWritesRate(double diskWritesRate) {
+ this.diskWritesRate = diskWritesRate;
+ }
+
+ public CircularFifoBuffer getDiskReadsPerSecTrend() {
+ return this.diskReadsPerSecTrend;
+ }
+
+ public void setDiskReadsPerSecTrend(CircularFifoBuffer diskReadsPerSecTrend) {
+ this.diskReadsPerSecTrend = diskReadsPerSecTrend;
+ }
+
+ public CircularFifoBuffer getDiskWritesPerSecTrend() {
+ return this.diskWritesPerSecTrend;
+ }
+
+ public void setDiskWritesPerSecTrend(
+ CircularFifoBuffer diskWritesPerSecTrend) {
+ this.diskWritesPerSecTrend = diskWritesPerSecTrend;
+ }
+
+ public double getGetsRate() {
+ return this.getsRate;
+ }
+
+ public void setGetsRate(double getsRate) {
+ this.getsRate = getsRate;
+ }
+
+ public double getLruEvictionRate() {
+ return this.lruEvictionRate;
+ }
+
+ public void setLruEvictionRate(double lruEvictionRate) {
+ this.lruEvictionRate = lruEvictionRate;
+ }
+
+ public String getRegionType() {
+ return this.regionType;
+ }
+
+ public void setRegionType(String regionType) {
+ this.regionType = regionType;
+ }
+
+ public long getSystemRegionEntryCount() {
+ return this.systemRegionEntryCount;
+ }
+
+ public void setSystemRegionEntryCount(long systemRegionEntryCount) {
+ this.systemRegionEntryCount = systemRegionEntryCount;
+ }
+
+ public int getMemberCount() {
+ return this.memberCount;
+ }
+
+ public void setMemberCount(int memberCount) {
+ this.memberCount = memberCount;
+ }
+
+ public double getPutsRate() {
+ return this.putsRate;
+ }
+
+ public void setPutsRate(double putsRate) {
+ this.putsRate = putsRate;
+ }
+
+ public CircularFifoBuffer getGetsPerSecTrend() {
+ return this.getsPerSecTrend;
+ }
+
+ public void setGetsPerSecTrend(CircularFifoBuffer getsPerSecTrend) {
+ this.getsPerSecTrend = getsPerSecTrend;
+ }
+
+ public CircularFifoBuffer getPutsPerSecTrend() {
+ return this.putsPerSecTrend;
+ }
+
+ public void setPutsPerSecTrend(CircularFifoBuffer putsPerSecTrend) {
+ this.putsPerSecTrend = putsPerSecTrend;
+ }
+
+ public boolean isEnableOffHeapMemory() {
+ return this.enableOffHeapMemory;
+ }
+
+ public void setEnableOffHeapMemory(boolean enableOffHeapMemory) {
+ this.enableOffHeapMemory = enableOffHeapMemory;
+ }
+
+ public String getCompressionCodec() {
+ return this.compressionCodec;
+ }
+
+ public void setCompressionCodec(String compressionCodec) {
+ this.compressionCodec = compressionCodec;
+ }
+
+ public Cluster.RegionOnMember[] getRegionOnMembers() {
+ Cluster.RegionOnMember[] regionOnMembers = null;
+ synchronized (this.regionOnMembers) {
+ regionOnMembers = new Cluster.RegionOnMember[this.regionOnMembers.size()];
+ regionOnMembers = this.regionOnMembers.toArray(regionOnMembers);
+ }
+
+ return regionOnMembers;
+ }
+
+ /**
+ * @param regionOnMembers the regionOnMembers to set
+ */
+ public void setRegionOnMembers(List<RegionOnMember> regionOnMembers) {
+ this.regionOnMembers = regionOnMembers;
+ }
+ }
+
+ /**
+ * Alert Inner Class
+ *
+ *
+ */
+ public static class Alert {
+ public static final int SEVERE = 0;
+ public static final int ERROR = 1;
+ public static final int WARNING = 2;
+ public static final int INFO = 3;
+
+ public static AtomicInteger ALERT_ID_CTR = new AtomicInteger();
+
+ private int id;
+ private Date timestamp;
+ private int severity;
+ private String memberName;
+ private String description;
+ private boolean isAcknowledged;
+ private String iso8601Ts;
+
+ public String getIso8601Ts() {
+ return iso8601Ts;
+ }
+
+ public void setIso8601Ts(String iso8601Ts) {
+ this.iso8601Ts = iso8601Ts;
+ }
+
+ public boolean isAcknowledged() {
+ return this.isAcknowledged;
+ }
+
+ public void setAcknowledged(boolean isAcknowledged) {
+ this.isAcknowledged = isAcknowledged;
+ }
+
+ public Date getTimestamp() {
+ return this.timestamp;
+ }
+
+ public void setTimestamp(Date timestamp) {
+ this.timestamp = timestamp;
+ this.iso8601Ts = formatToISOTimestamp(timestamp);
+ }
+
+ public int getSeverity() {
+ return this.severity;
+ }
+
+ public void setSeverity(int severity) {
+ this.severity = severity;
+ }
+
+ public String getMemberName() {
+ return this.memberName;
+ }
+
+ public void setMemberName(String memberName) {
+ this.memberName = memberName;
+ }
+
+ public String getDescription() {
+ return this.description;
+ }
+
+ public void setDescription(String description) {
+ this.description = description;
+ }
+
+ public int getId() {
+ return this.id;
+ }
+
+ public void setId(int id) {
+ this.id = id;
+ }
+
+ public static int nextID() {
+ /*
+ * int id = -1; synchronized (Alert.class) { ALERT_ID_CTR = ALERT_ID_CTR +
+ * 1; id = ALERT_ID_CTR; }
+ */
+ return ALERT_ID_CTR.incrementAndGet();
+ }
+
+ private static DateFormat df = new SimpleDateFormat(PulseConstants.PULSE_NOTIFICATION_ALERT_DATE_PATTERN);
+
+ public static String formatToISOTimestamp(Date date) {
+ TimeZone tz = TimeZone.getTimeZone("UTC");
+ df.setTimeZone(tz);
+ return df.format(date);
+ }
+
+ }
+
+ /**
+ * Client Inner Class
+ *
+ *
+ */
+ public static class Client {
+
+ private String id;
+ private String name;
+ private String host;
+ private int queueSize;
+ private double cpuUsage;
+ private long uptime;
+ private int threads;
+ private int gets;
+ private int puts;
+ private int cpus;
+ private int clientCQCount;
+ private long processCpuTime;
+ private String status;
+ private boolean isConnected = false;
+ private boolean isSubscriptionEnabled = false;
+
+ public String getId() {
+ return this.id;
+ }
+
+ public int getGets() {
+ return this.gets;
+ }
+
+ public int getPuts() {
+ return this.puts;
+ }
+
+ public int getClientCQCount() {
+ return clientCQCount;
+ }
+
+ public void setClientCQCount(int clientCQCount) {
+ this.clientCQCount = clientCQCount;
+ }
+
+ public boolean isSubscriptionEnabled() {
+ return isSubscriptionEnabled;
+ }
+
+ public void setSubscriptionEnabled(boolean isSubscriptionEnabled) {
+ this.isSubscriptionEnabled = isSubscriptionEnabled;
+ }
+
+ public void setId(String id) {
+ this.id = id;
+ }
+
+ public String getName() {
+ return this.name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public String getHost() {
+ return this.host;
+ }
+
+ public void setHost(String host) {
+ this.host = host;
+ }
+
+ public int getQueueSize() {
+ return this.queueSize;
+ }
+
+ public void setQueueSize(int queueSize) {
+ this.queueSize = queueSize;
+ }
+
+ public double getCpuUsage() {
+ return this.cpuUsage;
+ }
+
+ public void setCpuUsage(double cpuUsage) {
+ this.cpuUsage = cpuUsage;
+ }
+
+ public void setGets(int gets) {
+ this.gets = gets;
+ }
+
+ public void setPuts(int puts) {
+ this.puts = puts;
+ }
+
+ public long getUptime() {
+ return this.uptime;
+ }
+
+ public void setUptime(long uptime) {
+ this.uptime = uptime;
+ }
+
+ public int getThreads() {
+ return this.threads;
+ }
+
+ public void setThreads(int threads) {
+ this.threads = threads;
+ }
+
+ public String getStatus() {
+ return this.status;
+ }
+
+ public void setStatus(String status) {
+ this.status = status;
+ }
+
+ public int getCpus() {
+ return this.cpus;
+ }
+
+ public void setCpus(int cpus) {
+ this.cpus = cpus;
+ }
+
+ public long getProcessCpuTime() {
+ return this.processCpuTime;
+ }
+
+ public void setProcessCpuTime(long processCpuTime) {
+ this.processCpuTime = processCpuTime;
+ }
+
+ public boolean isConnected() {
+ return isConnected;
+ }
+
+ public void setConnected(boolean isConnected) {
+ this.isConnected = isConnected;
+ }
+
+ }
+
+ /**
+ * Gateway Receiver Inner Class
+ *
+ *
+ */
+ public static class GatewayReceiver {
+
+ private int listeningPort;
+ private double linkThroughput;
+ private long avgBatchProcessingTime;
+ private String id;
+ private int queueSize;
+ private Boolean status;
+ private int batchSize;
+
+ public int getListeningPort() {
+ return this.listeningPort;
+ }
+
+ public void setListeningPort(int listeningPort) {
+ this.listeningPort = listeningPort;
+ }
+
+ public double getLinkThroughput() {
+ return this.linkThroughput;
+ }
+
+ public void setLinkThroughput(double linkThroughput) {
+ this.linkThroughput = linkThroughput;
+ }
+
+ public long getAvgBatchProcessingTime() {
+ return this.avgBatchProcessingTime;
+ }
+
+ public void setAvgBatchProcessingTime(long avgBatchProcessingTime) {
+ this.avgBatchProcessingTime = avgBatchProcessingTime;
+ }
+
+ public String getId() {
+ return this.id;
+ }
+
+ public void setId(String id) {
+ this.id = id;
+ }
+
+ public int getQueueSize() {
+ return this.queueSize;
+ }
+
+ public void setQueueSize(int queueSize) {
+ this.queueSize = queueSize;
+ }
+
+ public Boolean getStatus() {
+ return this.status;
+ }
+
+ public void setStatus(Boolean status) {
+ this.status = status;
+ }
+
+ public int getBatchSize() {
+ return this.batchSize;
+ }
+
+ public void setBatchSize(int batchSize) {
+ this.batchSize = batchSize;
+ }
+ }
+
+ /**
+ * Gateway Sender Inner class
+ *
+ *
+ */
+ public static class GatewaySender {
+
+ private double linkThroughput;
+ private String id;
+ private int queueSize;
+ private Boolean status;
+ private boolean primary;
+ private boolean senderType;
+ private int batchSize;
+ private boolean persistenceEnabled;
+ private int remoteDSId;
+ private int eventsExceedingAlertThreshold;
+
+ public double getLinkThroughput() {
+ return this.linkThroughput;
+ }
+
+ public void setLinkThroughput(double linkThroughput) {
+ this.linkThroughput = linkThroughput;
+ }
+
+ public String getId() {
+ return this.id;
+ }
+
+ public void setId(String id) {
+ this.id = id;
+ }
+
+ public int getQueueSize() {
+ return this.queueSize;
+ }
+
+ public void setQueueSize(int queueSize) {
+ this.queueSize = queueSize;
+ }
+
+ public Boolean getStatus() {
+ return this.status;
+ }
+
+ public void setStatus(Boolean status) {
+ this.status = status;
+ }
+
+ public boolean getPrimary() {
+ return this.primary;
+ }
+
+ public void setPrimary(boolean primary) {
+ this.primary = primary;
+ }
+
+ public boolean getSenderType() {
+ return this.senderType;
+ }
+
+ public void setSenderType(boolean senderType) {
+ this.senderType = senderType;
+ }
+
+ public int getBatchSize() {
+ return this.batchSize;
+ }
+
+ public void setBatchSize(int batchSize) {
+ this.batchSize = batchSize;
+ }
+
+ public boolean getPersistenceEnabled() {
+ return this.persistenceEnabled;
+ }
+
+ public void setPersistenceEnabled(boolean persistenceEnabled) {
+ this.persistenceEnabled = persistenceEnabled;
+ }
+
+ /**
+ * @return the remoteDSId
+ */
+ public int getRemoteDSId() {
+ return remoteDSId;
+ }
+
+ /**
+ * @param remoteDSId the remoteDSId to set
+ */
+ public void setRemoteDSId(int remoteDSId) {
+ this.remoteDSId = remoteDSId;
+ }
+
+ /**
+ * @return the eventsExceedingAlertThreshold
+ */
+ public int getEventsExceedingAlertThreshold() {
+ return eventsExceedingAlertThreshold;
+ }
+
+ /**
+ * @param eventsExceedingAlertThreshold the eventsExceedingAlertThreshold to set
+ */
+ public void setEventsExceedingAlertThreshold(int eventsExceedingAlertThreshold) {
+ this.eventsExceedingAlertThreshold = eventsExceedingAlertThreshold;
+ }
+ }
+
+ /**
+ * Async Event Queue Inner class
+ *
+ *
+ */
+ public static class AsyncEventQueue {
+
+ private String id;
+ private boolean primary;
+ private boolean parallel;
+ private int batchSize;
+ private long batchTimeInterval;
+ private boolean batchConflationEnabled;
+ private String asyncEventListener;
+ private int eventQueueSize;
+
+ public String getId() {
+ return this.id;
+ }
+
+ public void setId(String id) {
+ this.id = id;
+ }
+
+ public boolean getPrimary() {
+ return this.primary;
+ }
+
+ public void setPrimary(boolean primary) {
+ this.primary = primary;
+ }
+
+ /**
+ * @return the parallel
+ */
+ public boolean isParallel() {
+ return parallel;
+ }
+
+ /**
+ * @param parallel the parallel to set
+ */
+ public void setParallel(boolean parallel) {
+ this.parallel = parallel;
+ }
+
+ public int getBatchSize() {
+ return this.batchSize;
+ }
+
+ public void setBatchSize(int batchSize) {
+ this.batchSize = batchSize;
+ }
+
+ /**
+ * @return the batchTimeInterval
+ */
+ public long getBatchTimeInterval() {
+ return batchTimeInterval;
+ }
+
+ /**
+ * @param batchTimeInterval the batchTimeInterval to set
+ */
+ public void setBatchTimeInterval(long batchTimeInterval) {
+ this.batchTimeInterval = batchTimeInterval;
+ }
+
+ /**
+ * @return the batchConflationEnabled
+ */
+ public boolean isBatchConflationEnabled() {
+ return batchConflationEnabled;
+ }
+
+ /**
+ * @param batchConflationEnabled the batchConflationEnabled to set
+ */
+ public void setBatchConflationEnabled(boolean batchConflationEnabled) {
+ this.batchConflationEnabled = batchConflationEnabled;
+ }
+
+ /**
+ * @return the asyncEventListener
+ */
+ public String getAsyncEventListener() {
+ return asyncEventListener;
+ }
+
+ /**
+ * @param asyncEventListener the asyncEventListener to set
+ */
+ public void setAsyncEventListener(String asyncEventListener) {
+ this.asyncEventListener = asyncEventListener;
+ }
+
+ /**
+ * @return the eventQueueSize
+ */
+ public int getEventQueueSize() {
+ return eventQueueSize;
+ }
+
+ /**
+ * @param eventQueueSize the eventQueueSize to set
+ */
+ public void setEventQueueSize(int eventQueueSize) {
+ this.eventQueueSize = eventQueueSize;
+ }
+ }
+
+ /**
+ * Default constructor only used for testing
+ */
+ public Cluster() {
+ }
+
+
+ /**
+ * This function is used for calling getUpdator function of ClusterDataFactory
+ * and starting the thread for updating the Cluster details.
+ *
+ * @param host
+ * host name
+ * @param port
+ * port
+ * @param userName
+ * pulse user name
+ * @param userPassword
+ * pulse user password
+ * @throws ConnectException
+ */
+ public Cluster(String host, String port, String userName, String userPassword)
+ throws ConnectException {
+ this.serverName = host;
+ this.port = port;
+ this.jmxUserName = userName;
+ this.jmxUserPassword = userPassword;
+
+ this.updater = ClusterDataFactory.getUpdater(this, host, port);
+ // start();
+ }
+
+ /**
+ * thread run method for updating the cluster data
+ */
+ @Override
+ public void run() {
+ while (!this.stopUpdates) {
+ try {
+ if (!this.updateData()) {
+ this.stale++;
+ } else {
+ this.stale = 0;
+ }
+ } catch (Exception e) {
+ if (LOGGER.infoEnabled()) {
+ LOGGER.info("Exception Occurred while updating cluster data : " + e.getMessage());
+ }
+ }
+
+ try {
+ Thread.sleep(POLL_INTERVAL);
+ } catch (InterruptedException e) {
+ if (LOGGER.infoEnabled()) {
+ LOGGER.info("InterruptedException Occurred : " + e.getMessage());
+ }
+ }
+ }
+
+ if (LOGGER.infoEnabled()) {
+ LOGGER.info(resourceBundle.getString("LOG_MSG_STOP_THREAD_UPDATES")
+ + " :: " + this.serverName + ":" + this.port);
+ }
+ }
+
+ /**
+ * calling updateData
+ *
+ * @return true if update was successful. false if it failed.
+ */
+ private boolean updateData() {
+ // This will eventually call JMX. Currently we will update this with
+ // some dummy data.
+ // Connect if required or hold a connection. If unable to connect,
+ // return false
+ if (LOGGER.finerEnabled()) {
+ LOGGER.finer(resourceBundle.getString("LOG_MSG_CLUSTER_DATA_IS_UPDATING")
+ + "::" + this.serverName + ":" + this.port);
+ }
+ return this.updater.updateData();
+ }
+
+ /**
+ * for stopping the update thread
+ */
+ public void stopThread() {
+ this.stopUpdates = true;
+
+ try {
+ join();
+ } catch (InterruptedException e) {
+ if (LOGGER.infoEnabled()) {
+ LOGGER.info("InterruptedException occured while stoping cluster thread : " + e.getMessage());
+ }
+ }
+ }
+
+ public Map<String, Cluster.Member> getMembersHMap() {
+ return this.membersHMap;
+ }
+
+ public void setMembersHMap(HashMap<String, Cluster.Member> membersHMap) {
+ this.membersHMap = membersHMap;
+ }
+
+ public Map<String, Boolean> getWanInformation() {
+ Map<String, Boolean> wanMap = null;
+ synchronized (this.wanInformation) {
+ wanMap = (Map<String, Boolean>) this.wanInformation.clone();
+ }
+
+ return wanMap;
+ }
+
+ // Returns actual wanInformation object reference
+ public Map<String, Boolean> getWanInformationObject() {
+ return this.wanInformation;
+ }
+
+ public void setWanInformation(HashMap<String, Boolean> wanInformation) {
+ this.wanInformation = wanInformation;
+ }
+
+ public String getJmxUserName() {
+ return this.jmxUserName;
+ }
+
+ public void setJmxUserName(String jmxUserName) {
+ this.jmxUserName = jmxUserName;
+ }
+
+ public String getJmxUserPassword() {
+ return this.jmxUserPassword;
+ }
+
+ public void setJmxUserPassword(String jmxUserPassword) {
+ this.jmxUserPassword = jmxUserPassword;
+ }
+
+ public String getConnectionErrorMsg() {
+ return this.connectionErrorMsg;
+ }
+
+ public void setConnectionErrorMsg(String connectionErrorMsg) {
+ this.connectionErrorMsg = connectionErrorMsg;
+ }
+
+ public String getServerName() {
+ return this.serverName;
+ }
+
+ public boolean isConnectedFlag() {
+ return this.connectedFlag;
+ }
+
+ public void setConnectedFlag(boolean connectedFlag) {
+ this.connectedFlag = connectedFlag;
+ }
+
+ public String getPort() {
+ return this.port;
+ }
+
+ public int getStale() {
+ return this.stale;
+ }
+
+ public double getWritePerSec() {
+ return this.writePerSec;
+ }
+
+ public void setWritePerSec(double writePerSec) {
+ this.writePerSec = writePerSec;
+ }
+
+ public double getReadPerSec() {
+ return this.readPerSec;
+ }
+
+ public void setReadPerSec(double readPerSec) {
+ this.readPerSec = readPerSec;
+ }
+
+ public double getQueriesPerSec() {
+ return this.queriesPerSec;
+ }
+
+ public void setQueriesPerSec(double queriesPerSec) {
+ this.queriesPerSec = queriesPerSec;
+ }
+
+ public double getLoadPerSec() {
+ return this.loadPerSec;
+ }
+
+ public void setLoadPerSec(double loadPerSec) {
+ this.loadPerSec = loadPerSec;
+ }
+
+ public int getNotificationPageNumber() {
+ return this.notificationPageNumber;
+ }
+
+ public void setNotificationPageNumber(int notificationPageNumber) {
+ this.notificationPageNumber = notificationPageNumber;
+ }
+
+ public void setStale(int stale) {
+ this.stale = stale;
+ }
+
+ public boolean isStopUpdates() {
+ return this.stopUpdates;
+ }
+
+ public void setStopUpdates(boolean stopUpdates) {
+ this.stopUpdates = stopUpdates;
+ }
+
+ public long getUsedHeapSize() {
+ return this.usedHeapSize;
+ }
+
+ public void setUsedHeapSize(long usedHeapSize) {
+ this.usedHeapSize = usedHeapSize;
+ }
+
+ public int getServerCount() {
+ return this.serverCount;
+ }
+
+ public void setServerCount(int serverCount) {
+ this.serverCount = serverCount;
+ }
+
+ public int getTxnCommittedCount() {
+ return txnCommittedCount;
+ }
+
+ public void setTxnCommittedCount(int txnCommittedCount) {
+ this.txnCommittedCount = txnCommittedCount;
+ }
+
+ public int getTxnRollbackCount() {
+ return txnRollbackCount;
+ }
+
+ public void setTxnRollbackCount(int txnRollbackCount) {
+ this.txnRollbackCount = txnRollbackCount;
+ }
+
+ public int getRunningFunctionCount() {
+ return this.runningFunctionCount;
+ }
+
+ public long getRegisteredCQCount() {
+ return this.registeredCQCount;
+ }
+
+ public int getSubscriptionCount() {
+ return this.subscriptionCount;
+ }
+
+ public void setSubscriptionCount(int subscriptionCount) {
+ this.subscriptionCount = subscriptionCount;
+ }
+
+ public void setRegisteredCQCount(long registeredCQCount) {
+ this.registeredCQCount = registeredCQCount;
+ }
+
+ public void setRunningFunctionCount(int runningFunctionCount) {
+ this.runningFunctionCount = runningFunctionCount;
+ }
+
+ public Map<String, Cluster.Region> getClusterRegions() {
+ return this.clusterRegionMap;
+ }
+
+ public Cluster.Region getClusterRegion(String regionFullPath) {
+ return this.clusterRegionMap.get(regionFullPath);
+ }
+
+ public void setClusterRegions(Map<String, Region> clusterRegionMap) {
+ this.clusterRegionMap = clusterRegionMap;
+ }
+
+ public Map<String, Cluster.Statement> getClusterStatements() {
+ return this.clusterStatementMap;
+ }
+
+ public void setClusterStatements(Map<String, Statement> clusterStatementMap) {
+ this.clusterStatementMap = clusterStatementMap;
+ }
+
+ public Alert[] getAlertsList() {
+ Alert[] list = null;
+ synchronized (this.alertsList) {
+ list = new Alert[this.alertsList.size()];
+ list = this.alertsList.toArray(list);
+ }
+
+ return list;
+ }
+
+ public void setAlertsList(List<Alert> alertsList) {
+ this.alertsList = alertsList;
+ }
+
+ public void setServerName(String serverName) {
+ this.serverName = serverName;
+ }
+
+ public void setPort(String port) {
+ this.port = port;
+ }
+
+ public Set<String> getDeletedMembers() {
+ return this.deletedMembers;
+ }
+
+ public void setDeletedMembers(Set<String> deletedMembers) {
+ this.deletedMembers = deletedMembers;
+ }
+
+ public Set<String> getDeletedRegions() {
+ return this.deletedRegions;
+ }
+
+ public void setDeletedRegions(Set<String> deletedRegions) {
+ this.deletedRegions = deletedRegions;
+ }
+
+ public Map<String, List<Member>> getPhysicalToMember() {
+ Map<String, List<Member>> ptom = null;
+ // synchronized (physicalToMember) {
+ ptom = this.physicalToMember;
+ // }
+ return ptom;
+ }
+
+ public void setPhysicalToMember(HashMap<String, List<Member>> physicalToMember) {
+ // synchronized (this.physicalToMember) {
+ this.physicalToMember = physicalToMember;
+ // }
+ }
+
+ public int getMemberCount() {
+ return this.memberCount;
+ }
+
+ public void setMemberCount(int memberCount) {
+ this.memberCount = memberCount;
+ }
+
+ public long getClientConnectionCount() {
+ return this.clientConnectionCount;
+ }
+
+ public void setClientConnectionCount(long clientConnectionCount) {
+ this.clientConnectionCount = clientConnectionCount;
+ }
+
+ public int getClusterId() {
+ return this.clusterId;
+ }
+
+ public void setClusterId(int clusterId) {
+ this.clusterId = clusterId;
+ }
+
+ public int getLocatorCount() {
+ return this.locatorCount;
+ }
+
+ public void setLocatorCount(int locatorCount) {
+ this.locatorCount = locatorCount;
+ }
+
+ public int getTotalRegionCount() {
+ return this.totalRegionCount;
+ }
+
+ public void setTotalRegionCount(int totalRegionCount) {
+ this.totalRegionCount = totalRegionCount;
+ }
+
+ public long getTotalHeapSize() {
+ return this.totalHeapSize;
+ }
+
+ public void setTotalHeapSize(long totalHeapSize) {
+ this.totalHeapSize = totalHeapSize;
+ }
+
+ public long getTotalRegionEntryCount() {
+ return this.totalRegionEntryCount;
+ }
+
+ public void setTotalRegionEntryCount(long totalRegionEntryCount) {
+ this.totalRegionEntryCount = totalRegionEntryCount;
+ }
+
+ public int getCurrentQueryCount() {
+ return this.currentQueryCount;
+ }
+
+ public void setCurrentQueryCount(int currentQueryCount) {
+ this.currentQueryCount = currentQueryCount;
+ }
+
+ public long getTotalBytesOnDisk() {
+ return this.totalBytesOnDisk;
+ }
+
+ public void setTotalBytesOnDisk(long totalBytesOnDisk) {
+ this.totalBytesOnDisk = totalBytesOnDisk;
+ }
+
+ public double getDiskReadsRate() {
+ return this.diskReadsRate;
+ }
+
+ public void setDiskReadsRate(double diskReadsRate) {
+ this.diskReadsRate = diskReadsRate;
+ }
+
+ public double getDiskWritesRate() {
+ return this.diskWritesRate;
+ }
+
+ public void setDiskWritesRate(double diskWritesRate) {
+ this.diskWritesRate = diskWritesRate;
+ }
+
+ public int getAvgDiskStorage() {
+ return this.avgDiskStorage;
+ }
+
+ public void setAvgDiskStorage(int avgDiskStorage) {
+ this.avgDiskStorage = avgDiskStorage;
+ }
+
+ public int getAvgDiskWritesRate() {
+ return this.avgDiskWritesRate;
+ }
+
+ public void setAvgDiskWritesRate(int avgDiskWritesRate) {
+ this.avgDiskWritesRate = avgDiskWritesRate;
+ }
+
+ public CircularFifoBuffer getWritePerSecTrend() {
+ return this.writePerSecTrend;
+ }
+
+ public void setWritePerSecTrend(CircularFifoBuffer writePerSecTrend) {
+ this.writePerSecTrend = writePerSecTrend;
+ }
+
+ public long getGarbageCollectionCount() {
+ return this.garbageCollectionCount;
+ }
+
+ public void setGarbageCollectionCount(long garbageCollectionCount) {
+ this.garbageCollectionCount = garbageCollectionCount;
+ }
+
+ public CircularFifoBuffer getTotalBytesOnDiskTrend() {
+ return this.totalBytesOnDiskTrend;
+ }
+
+ public void setTotalBytesOnDiskTrend(CircularFifoBuffer totalBytesOnDiskTrend) {
+ this.totalBytesOnDiskTrend = totalBytesOnDiskTrend;
+ }
+
+ public CircularFifoBuffer getThroughoutWritesTrend() {
+ return this.throughoutWritesTrend;
+ }
+
+ public void setThroughoutWritesTrend(CircularFifoBuffer throughoutWritesTrend) {
+ this.throughoutWritesTrend = throughoutWritesTrend;
+ }
+
+ public CircularFifoBuffer getThroughoutReadsTrend() {
+ return this.throughoutReadsTrend;
+ }
+
+ public void setThroughoutReadsTrend(CircularFifoBuffer throughoutReadsTrend) {
+ this.throughoutReadsTrend = throughoutReadsTrend;
+ }
+
+ public CircularFifoBuffer getReadPerSecTrend() {
+ return this.readPerSecTrend;
+ }
+
+ public void setReadPerSecTrend(CircularFifoBuffer readPerSecTrend) {
+ this.readPerSecTrend = readPerSecTrend;
+ }
+
+ public CircularFifoBuffer getQueriesPerSecTrend() {
+ return this.queriesPerSecTrend;
+ }
+
+ public void setQueriesPerSecTrend(CircularFifoBuffer queriesPerSecTrend) {
+ this.queriesPerSecTrend = queriesPerSecTrend;
+ }
+
+ public CircularFifoBuffer getMemoryUsageTrend() {
+ return this.memoryUsageTrend;
+ }
+
+ public void setMemoryUsageTrend(CircularFifoBuffer memoryUsageTrend) {
+ this.memoryUsageTrend = memoryUsageTrend;
+ }
+
+ public CircularFifoBuffer getGarbageCollectionTrend() {
+ return this.garbageCollectionTrend;
+ }
+
+ public void setGarbageCollectionTrend(
+ CircularFifoBuffer garbageCollectionSamples) {
+ this.garbageCollectionTrend = garbageCollectionSamples;
+ }
+
+ public long getPreviousJVMPauseCount() {
+ return this.previousJVMPauseCount;
+ }
+
+ public void setPreviousJVMPauseCount(long previousJVMPauseCount) {
+ this.previousJVMPauseCount = previousJVMPauseCount;
+ }
+
+ public DataBrowser getDataBrowser() {
+ // Initialize dataBrowser if null
+ if (this.dataBrowser == null) {
+ this.dataBrowser = new DataBrowser();
+ }
+ return this.dataBrowser;
+ }
+
+ public void setDataBrowser(DataBrowser dataBrowser) {
+ this.dataBrowser = dataBrowser;
+ }
+
+ public ObjectNode executeQuery(String queryText, String members, int limit) {
+ // Execute data browser query
+ return this.updater.executeQuery(queryText, members, limit);
+ }
+
+ public ArrayNode getQueryHistoryByUserId(String userId) {
+ return this.getDataBrowser().getQueryHistoryByUserId(userId);
+ }
+
+ public boolean addQueryInHistory(String queryText, String userName) {
+ return this.getDataBrowser().addQueryInHistory(queryText, userName);
+ }
+
+ public boolean deleteQueryById(String userId, String queryId) {
+ return this.getDataBrowser().deleteQueryById(userId, queryId);
+ }
+
+ public JMXConnector connectToGemFire() {
+ if(this.updater instanceof JMXDataUpdater) {
+ return ((JMXDataUpdater) this.updater).getJMXConnection(false);
+ } else {
+ return null;
+ }
+ }
+
+ /**
+ * inner class for creating Mock Data
+ *
+ *
+ */
+ public class MockDataUpdater implements IClusterUpdater {
+ public MockDataUpdater() {
+ }
+
+ /**
+ * function used for updating Cluster data for Mock
+ */
+ @Override
+ public boolean updateData() {
+ setConnectedFlag(true);
+ Random r = new Random(System.currentTimeMillis());
+ totalHeapSize = (long) Math.abs(r.nextInt(3200 - 2048) + 2048);
+ usedHeapSize = (long) Math.abs(r.nextInt(2048));
+ writePerSec = Math.abs(r.nextInt(100));
+ subscriptionCount = Math.abs(r.nextInt(100));
+ registeredCQCount = (long) Math.abs(r.nextInt(100));
+ txnCommittedCount = Math.abs(r.nextInt(100));
+ txnRollbackCount = Math.abs(r.nextInt(100));
+ runningFunctionCount = Math.abs(r.nextInt(100));
+ clusterId = Math.abs(r.nextInt(100));
+ writePerSecTrend.add(writePerSec);
+ diskWritesRate = writePerSec;
+ garbageCollectionCount = (long) Math.abs(r.nextInt(100));
+ garbageCollectionTrend.add(garbageCollectionCount);
+
+ readPerSec = Math.abs(r.nextInt(100));
+ readPerSecTrend.add(readPerSec);
+
+ diskReadsRate = readPerSec;
+ queriesPerSec = Math.abs(r.nextInt(100));
+ queriesPerSecTrend.add(queriesPerSec);
+
+ loadPerSec = Math.abs(r.nextInt(100));
+ totalHeapSize = totalHeapSize;
+ totalBytesOnDisk = totalHeapSize;
+
+ totalBytesOnDiskTrend.add(totalBytesOnDisk);
+
+ memoryUsageTrend.add(usedHeapSize);
+ throughoutWritesTrend.add(writePerSec);
+ throughoutReadsTrend.add(readPerSec);
+
+ memberCount = 0;
+
+ // Create 3 members first time around
+ if (membersHMap.size() == 0) {
+
+ membersHMap.put(
+ "pnq-visitor1",
+ initializeMember(
+ "pnq-visitor1(Launcher_Manager-1099-13-40-24-5368)-24357",
+ "pnq-visitor1", true, true, true, true));
+
+ for (int i = 2; i <= 8; i++) {
+ if ((i % 2) == 0) {
+ membersHMap.put(
+ "pnq-visitor" + i,
+ initializeMember("pnq-visitor" + i
+ + "(Launcher_Server-1099-13-40-24-5368)-24357",
+ "pnq-visitor" + i, false, false, true, false));
+ } else {
+ if ((i % 3) == 0) {
+ membersHMap.put(
+ "pnq-visitor" + i,
+ initializeMember("pnq-visitor" + i
+ + "(Launcher_Server-1099-13-40-24-5368)-24357",
+ "pnq-visitor" + i, false, false, false, false));
+ } else {
+ membersHMap.put(
+ "pnq-visitor" + i,
+ initializeMember("pnq-visitor" + i
+ + "(Launcher_Server-1099-13-40-24-5368)-24357",
+ "pnq-visitor" + i, false, true, true, true));
+ }
+ }
+ }
+
+ for (Entry<String, Member> memberSet : membersHMap.entrySet()) {
+ HashMap<String, Cluster.Region> memberRegions = new HashMap<String, Cluster.Region>();
+ HashMap<String, Cluster.Client> memberClientsHM = new HashMap<String, Cluster.Client>();
+
+ Random randomGenerator = new Random();
+ int randomInt = (randomGenerator.nextInt(15)) + 10;
+ int regionExists = 0;
+ for (int y = 0; y < randomInt; y++) {
+ Region region = initMemberRegion(y, memberSet.getValue().getName());
+ if (clusterRegionMap.entrySet().size() > 0) {
+ for (Region clusterRegion : clusterRegionMap.values()) {
+ if ((region.name).equals(clusterRegion.name)) {
+ clusterRegion.memberName.add(memberSet.getValue().getName());
+ clusterRegion.memberCount = clusterRegion.memberCount + 1;
+ regionExists = 1;
+ break;
+ }
+ }
+ if (regionExists == 0) {
+ addClusterRegion(region.getFullPath(), region);
+ }
+ } else {
+ addClusterRegion(region.getFullPath(), region);
+ }
+ memberRegions.put(region.getFullPath(), region);
+ totalRegionCount = clusterRegionMap.values().size();
+ }
+ membersHMap.get(memberSet.getKey()).setMemberRegions(memberRegions);
+
+ if (memberSet.getValue().isCache) {
+ Client client = initMemberClient(0, memberSet.getValue().getHost());
+ memberClientsHM.put(client.getId(), client);
+ randomInt = randomGenerator.nextInt(10);
+ for (int y = 1; y < randomInt; y++) {
+ Client newClient = initMemberClient(y, memberSet.getValue()
+ .getHost());
+ memberClientsHM.put(newClient.getId(), newClient);
+ }
+ membersHMap.get(memberSet.getKey()).updateMemberClientsHMap(
+ memberClientsHM);
+ clientConnectionCount = clientConnectionCount
+ + membersHMap.get(memberSet.getKey()).getMemberClientsHMap()
+ .size();
+ }
+
+ }
+ }
+
+ // add additional regions to members
+ for (Entry<String, Member> memberSet : membersHMap.entrySet()) {
+ HashMap<String, Cluster.Region> memberRegions = new HashMap<String, Cluster.Region>();
+
+ Random randomGenerator = new Random();
+ int randomInt = (randomGenerator.nextInt(5)) + 5;
+ int regionExists = 0;
+ for (int y = 0; y < randomInt; y++) {
+ Region region = initMemberRegion(y, memberSet.getValue().getName());
+ if (clusterRegionMap.entrySet().size() > 0) {
+ for (Region clusterRegion : clusterRegionMap.values()) {
+ if ((region.name).equals(clusterRegion.name)) {
+ clusterRegion.memberName.add(memberSet.getValue().getName());
+ clusterRegion.memberCount = clusterRegion.memberCount + 1;
+ regionExists = 1;
+ break;
+ }
+ }
+ if (regionExists == 0) {
+ addClusterRegion(region.getFullPath(), region);
+ }
+ } else {
+ addClusterRegion(region.getFullPath(), region);
+ }
+ memberRegions.put(region.getFullPath(), region);
+ totalRegionCount = clusterRegionMap.values().size();
+ }
+ membersHMap.get(memberSet.getKey()).setMemberRegions(memberRegions);
+
+ }
+
+ wanInformation.clear();
+ int wanInfoSize = Math.abs(r.nextInt(10));
+ wanInfoSize++;
+ for (int i = 0; i < wanInfoSize; i++) {
+ String name = "Mock Cluster" + i;
+ Boolean value = false;
+ if (i % 2 == 0) {
+ value = true;
+ }
+ wanInformation.put(name, value);
+ }
+ memberCount = membersHMap.size();
+
+ totalHeapSize = (long) 0;
+ for (Entry<String, Member> memberSet : membersHMap.entrySet()) {
+ refresh(membersHMap.get(memberSet.getKey()));
+ Member member = membersHMap.get(memberSet.getKey());
+ totalHeapSize += member.currentHeapSize;
+ }
+
+ for (Region region : clusterRegionMap.values()) {
+ // Memory reads and writes
+ region.getsRate = (Math.abs(r.nextInt(100))) + 1;
+ region.putsRate = (Math.abs(r.nextInt(100))) + 1;
+ region.getsPerSecTrend.add(region.getsRate);
+ region.putsPerSecTrend.add(region.putsRate);
+
+ // Disk reads and writes
+ region.diskReadsRate = (Math.abs(r.nextInt(100))) + 1;
+ region.diskWritesRate = (Math.abs(r.nextInt(100))) + 1;
+ region.diskReadsPerSecTrend.add(region.diskReadsRate);
+ region.diskWritesPerSecTrend.add(region.diskWritesRate);
+ }
+
+ if(clusterStatementMap.size() < 500){
+ for(int i = 1; i <= 500; ++i) {
+
<TRUNCATED>