http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/9a2b5d7b/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..e15d282 --- /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 com.vmware.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 com.vmware.geode.tools.pulse.internal.log.PulseLogWriter; +import com.vmware.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>