Java tutorial
/* * 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.synapse.endpoints; import org.apache.axis2.transport.base.MessageLevelMetricsCollector; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import java.util.*; import java.util.concurrent.*; import java.util.concurrent.atomic.AtomicInteger; /** * This class is the metrics collector and JMX control point for Endpoints */ public class EndpointView implements EndpointViewMBean, MessageLevelMetricsCollector { private static final Log log = LogFactory.getLog(EndpointView.class); private static final Long ONE = 1L; private static final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(20, new ThreadFactory() { public Thread newThread(Runnable r) { return new Thread(r, "endpoint-jmx-stat-collector"); } }); /** The name of the endpoint */ private String endpointName = null; /** The actual Endpoint implementation we manage */ private Endpoint endpoint = null; // metrics collected / maintained private long messagesReceived; private long faultsReceiving; private long timeoutsReceiving; private long bytesReceived; private long minSizeReceived; private long maxSizeReceived; private double avgSizeReceived; private final Map<Integer, Long> receivingFaultTable = Collections .synchronizedMap(new HashMap<Integer, Long>()); private long messagesSent; private long faultsSending; private long timeoutsSending; private long bytesSent; private long minSizeSent; private long maxSizeSent; private double avgSizeSent; private int consecutiveSuspensions; private int consecutiveTimeouts; private int totalSuspensions; private int totalTimeouts; private AtomicInteger suspensions = new AtomicInteger(0); private AtomicInteger timeouts = new AtomicInteger(0); private Date suspendedAt; private Date timedoutAt; private final Map<Integer, Long> sendingFaultTable = Collections.synchronizedMap(new HashMap<Integer, Long>()); private final Map<Integer, Long> responseCodeTable = Collections.synchronizedMap(new HashMap<Integer, Long>()); private long lastResetTime = System.currentTimeMillis(); private ScheduledFuture future; private Queue<Integer> suspensionCounts = new LinkedList<Integer>(); private Queue<Integer> timeoutCounts = new LinkedList<Integer>(); /** * Create a new MBean to manage the given endpoint * @param endpointName the name of the endpoint * @param endpoint the actual endpoint */ public EndpointView(final String endpointName, Endpoint endpoint) { this.endpointName = endpointName; this.endpoint = endpoint; this.future = scheduler.scheduleAtFixedRate(new Runnable() { public void run() { if (suspensionCounts.size() == 15) { suspensionCounts.remove(); } suspensionCounts.offer(suspensions.getAndSet(0)); if (timeoutCounts.size() == 15) { timeoutCounts.remove(); } timeoutCounts.offer(timeouts.getAndSet(0)); } }, 60, 60, TimeUnit.SECONDS); } public void destroy() { future.cancel(true); suspensionCounts.clear(); timeoutCounts.clear(); } // --- endpoint control --- /** * Switch on a leaf endpoint, or all endpoints on a group - from maintenance * @throws Exception */ public void switchOn() throws Exception { if (endpoint.getChildren() != null) { for (Endpoint e : endpoint.getChildren()) { if (e.getMetricsMBean() != null) { e.getMetricsMBean().switchOn(); } } } else { if (endpoint.getContext() != null) { endpoint.getContext().switchOn(); } } } /** * Switch off a leaf endpoint, or all endpoints of a group - for maintenance * * @throws Exception */ public void switchOff() throws Exception { if (endpoint.getChildren() != null) { for (Endpoint e : endpoint.getChildren()) { if (e.getMetricsMBean() != null) { e.getMetricsMBean().switchOff(); } } } else { if (endpoint.getContext() != null) { endpoint.getContext().switchOff(); } } } // --- endpoint status check --- /** * Is a leaf level endpoint active? For a group endpoint this means at least one is active * @return true if at least one is active in a group endpoint; for a leaf - if it is currently active * @throws Exception */ public boolean isActive() throws Exception { if (endpoint.getChildren() != null) { return getActiveChildren() > 0; } else if (endpoint.getContext() != null) { return endpoint.getContext().isState(EndpointContext.ST_ACTIVE); } return false; } /** * Is this leaf level endpoint in timeout state? For a group, has all endpoints timed out? * @return true if a leaf level endpoint has timed out, For a group, has all endpoints timed out? * @throws Exception */ public boolean isTimedout() throws Exception { return isEndpointInState(EndpointContext.ST_TIMEOUT); } /** * Is this leaf level endpoint in suspend state? * @return true if a leaf level endpoint is suspended, false for group endpoints and non-suspend * @throws Exception */ public boolean isSuspended() throws Exception { return isEndpointInState(EndpointContext.ST_SUSPENDED); } /** * Is this leaf level endpoint switched off? * @return true if a leaf level endpoint is off, false for group endpoints and non-off * @throws Exception */ public boolean isSwitchedOff() throws Exception { return isEndpointInState(EndpointContext.ST_OFF); } /** * Return number of children for this endpoint * @return the number of children for this endpoint * @throws Exception */ public int getTotalChildren() throws Exception { return (endpoint.getChildren() == null ? 0 : endpoint.getChildren().size()); } /** * Return the number of active children for this endpoint * @return the number of active children for this endpoint * @throws Exception */ public int getActiveChildren() throws Exception { if (endpoint.getChildren() == null) { return 0; } else { int activeCount = 0; for (Endpoint e : endpoint.getChildren()) { if (e.getContext().isState(EndpointContext.ST_ACTIVE)) { activeCount++; } } return activeCount; } } /** * Return the number of ready children for this endpoint * @return the number of ready children for this endpoint * @throws Exception */ public int getReadyChildren() throws Exception { if (endpoint.getChildren() == null) { return 0; } else { int readyCount = 0; for (Endpoint e : endpoint.getChildren()) { if (e.getContext().readyToSend()) { readyCount++; } } return readyCount; } } // --- endpoint metrics --- /** * Time when statistics was last reset for this leaf endpoint * @return the time when statistics was last reset for this leaf endpoint, or -1 for group endpoints */ public long getLastResetTime() { return (endpoint.getChildren() != null ? -1 : lastResetTime); } /** * Time since statistics was last reset for this leaf endpoint * @return the time since statistics was last reset for this leaf endpoint, or -1 for group endpoints */ public long getMetricsWindow() { return (endpoint.getChildren() != null ? -1 : System.currentTimeMillis() - lastResetTime); } /** * A Map of receive faults with the error code and count * @return a Map of receive faults */ public Map<Integer, Long> getReceivingFaultTable() { if (endpoint.getChildren() != null) { Map<Integer, Long> receivingFaultTable = new HashMap<Integer, Long>(); for (Endpoint e : endpoint.getChildren()) { if (e.getMetricsMBean() != null) { addTableMaps(receivingFaultTable, e.getMetricsMBean().getReceivingFaultTable()); } } addTableMaps(receivingFaultTable, this.receivingFaultTable); return receivingFaultTable; } else { return receivingFaultTable; } } /** * A Map of send faults with the error code and count * @return a Map of send faults */ public Map<Integer, Long> getSendingFaultTable() { if (endpoint.getChildren() != null) { Map<Integer, Long> sendingFaultTable = new HashMap<Integer, Long>(); for (Endpoint e : endpoint.getChildren()) { if (e.getMetricsMBean() != null) { addTableMaps(sendingFaultTable, e.getMetricsMBean().getSendingFaultTable()); } } addTableMaps(sendingFaultTable, this.sendingFaultTable); return sendingFaultTable; } else { return sendingFaultTable; } } /** * A Map of response codes and counts * @return a Map of response codes and counts */ public Map<Integer, Long> getResponseCodeTable() { if (endpoint.getChildren() != null) { Map<Integer, Long> responseCodeTable = new HashMap<Integer, Long>(); for (Endpoint e : endpoint.getChildren()) { if (e.getMetricsMBean() != null) { addTableMaps(responseCodeTable, e.getMetricsMBean().getResponseCodeTable()); } } return responseCodeTable; } else { return responseCodeTable; } } public Date getSuspendedAt() { return suspendedAt; } public void setSuspendedAt(Date suspendedAt) { this.suspendedAt = suspendedAt; } public Date getTimedoutAt() { return timedoutAt; } public void setTimedoutAt(Date timedoutAt) { this.timedoutAt = timedoutAt; } public int getConsecutiveEndpointSuspensions() { return consecutiveSuspensions; } public void incrementSuspensions() { consecutiveSuspensions++; totalSuspensions++; suspensions.incrementAndGet(); } public void resetConsecutiveSuspensions() { consecutiveSuspensions = 0; } public int getConsecutiveEndpointTimeouts() { return consecutiveTimeouts; } public void incrementTimeouts() { consecutiveTimeouts++; totalTimeouts++; timeouts.incrementAndGet(); } public void resetConsecutiveTimeouts() { consecutiveTimeouts = 0; } public int getTotalEndpointSuspensions() { return totalSuspensions; } public int getTotalEndpointTimeouts() { return totalTimeouts; } public int getLastMinuteEndpointSuspensions() { return getTotal(suspensionCounts, 1); } public int getLast5MinuteEndpointSuspensions() { return getTotal(suspensionCounts, 5); } public int getLast15MinuteEndpointSuspensions() { return getTotal(suspensionCounts, 15); } public int getLastMinuteEndpointTimeouts() { return getTotal(timeoutCounts, 1); } public int getLast5MinuteEndpointTimeouts() { return getTotal(timeoutCounts, 5); } public int getLast15MinuteEndpointTimeouts() { return getTotal(timeoutCounts, 15); } private int getTotal(Queue<Integer> queue, int count) { int sum = 0; Integer[] array = queue.toArray(new Integer[queue.size()]); if (count > array.length) { for (int i = 0; i < array.length; i++) { sum += array[i]; } } else { for (int i = 0; i < count; i++) { sum += array[array.length - 1 - i]; } } return sum; } /** * Number of messages (ie replies) received * @return # of messages (replies) received */ public long getMessagesReceived() { if (endpoint.getChildren() != null) { long messagesReceived = 0; for (Endpoint e : endpoint.getChildren()) { if (e.getMetricsMBean() != null) { messagesReceived += e.getMetricsMBean().getMessagesReceived(); } } return messagesReceived; } else { return messagesReceived; } } /** * Number of faults, receiving replies * @return # of faults, receiving replies */ public long getFaultsReceiving() { if (endpoint.getChildren() != null) { long faultsReceiving = 0; for (Endpoint e : endpoint.getChildren()) { if (e.getMetricsMBean() != null) { faultsReceiving += e.getMetricsMBean().getFaultsReceiving(); } } return faultsReceiving; } else { return faultsReceiving; } } /** * Number of timeouts, receiving replies * @return # of timeouts, receiving replies */ public long getTimeoutsReceiving() { if (endpoint.getChildren() != null) { long timeoutsReceiving = 0; for (Endpoint e : endpoint.getChildren()) { if (e.getMetricsMBean() != null) { timeoutsReceiving += e.getMetricsMBean().getTimeoutsReceiving(); } } return timeoutsReceiving; } else { return timeoutsReceiving; } } /** * Number of bytes received, receiving replies * @return # of bytes received, receiving replies */ public long getBytesReceived() { if (endpoint.getChildren() != null) { long bytesReceived = 0; for (Endpoint e : endpoint.getChildren()) { if (e.getMetricsMBean() != null) { bytesReceived += e.getMetricsMBean().getBytesReceived(); } } return bytesReceived; } else { return bytesReceived; } } /** * Number of messages sent * @return # of messages sent */ public long getMessagesSent() { if (endpoint.getChildren() != null) { long messagesSent = 0; for (Endpoint e : endpoint.getChildren()) { if (e.getMetricsMBean() != null) { messagesSent += e.getMetricsMBean().getMessagesSent(); } } return messagesSent; } else { return messagesSent; } } /** * Number of faults sending * @return # of faults sending */ public long getFaultsSending() { if (endpoint.getChildren() != null) { long faultsSending = 0; for (Endpoint e : endpoint.getChildren()) { if (e.getMetricsMBean() != null) { faultsSending += e.getMetricsMBean().getFaultsSending(); } } return faultsSending; } else { return faultsSending; } } /** * Number of timeouts, sending * @return # of timeouts, sending */ public long getTimeoutsSending() { if (endpoint.getChildren() != null) { long timeoutsSending = 0; for (Endpoint e : endpoint.getChildren()) { if (e.getMetricsMBean() != null) { timeoutsSending += e.getMetricsMBean().getTimeoutsSending(); } } return timeoutsSending; } else { return timeoutsSending; } } /** * Number of bytes sent * @return # of bytes sent */ public long getBytesSent() { if (endpoint.getChildren() != null) { long bytesSent = 0; for (Endpoint e : endpoint.getChildren()) { if (e.getMetricsMBean() != null) { bytesSent += e.getMetricsMBean().getBytesSent(); } } return bytesSent; } else { return bytesSent; } } public long getMinSizeReceived() { if (endpoint.getChildren() != null) { long minSizeReceived = 0; for (Endpoint e : endpoint.getChildren()) { if (e.getMetricsMBean() != null) { if (minSizeReceived == 0) { minSizeReceived = e.getMetricsMBean().getMinSizeReceived(); } else if (e.getMetricsMBean().getMinSizeReceived() < minSizeReceived) { minSizeReceived = e.getMetricsMBean().getMinSizeReceived(); } } } return minSizeReceived; } else { return minSizeReceived; } } public long getMaxSizeReceived() { if (endpoint.getChildren() != null) { long maxSizeReceived = 0; for (Endpoint e : endpoint.getChildren()) { if (e.getMetricsMBean() != null) { if (maxSizeReceived == 0) { maxSizeReceived = e.getMetricsMBean().getMaxSizeReceived(); } else if (e.getMetricsMBean().getMaxSizeReceived() > maxSizeReceived) { maxSizeReceived = e.getMetricsMBean().getMaxSizeReceived(); } } } return maxSizeReceived; } else { return maxSizeReceived; } } public long getMinSizeSent() { if (endpoint.getChildren() != null) { long minSizeSent = 0; for (Endpoint e : endpoint.getChildren()) { if (e.getMetricsMBean() != null) { if (minSizeSent == 0) { minSizeSent = e.getMetricsMBean().getMinSizeSent(); } else if (e.getMetricsMBean().getMinSizeSent() < minSizeSent) { minSizeSent = e.getMetricsMBean().getMinSizeSent(); } } } return minSizeSent; } else { return minSizeSent; } } public long getMaxSizeSent() { if (endpoint.getChildren() != null) { long maxSizeSent = 0; for (Endpoint e : endpoint.getChildren()) { if (e.getMetricsMBean() != null) { if (maxSizeSent == 0) { maxSizeSent = e.getMetricsMBean().getMaxSizeSent(); } else if (e.getMetricsMBean().getMaxSizeSent() > maxSizeSent) { maxSizeSent = e.getMetricsMBean().getMaxSizeSent(); } } } return maxSizeSent; } else { return maxSizeSent; } } public double getAvgSizeReceived() { if (endpoint.getChildren() != null) { double avgSizeReceived = 0; for (Endpoint e : endpoint.getChildren()) { double epValue = e.getMetricsMBean() == null ? 0 : e.getMetricsMBean().getAvgSizeReceived(); if (epValue > 0) { avgSizeReceived = (avgSizeReceived == 0 ? epValue : (avgSizeReceived + epValue) / 2); } } return avgSizeReceived; } else { return avgSizeReceived; } } public double getAvgSizeSent() { if (endpoint.getChildren() != null) { double avgSizeSent = 0; for (Endpoint e : endpoint.getChildren()) { double epValue = e.getMetricsMBean() == null ? 0 : e.getMetricsMBean().getAvgSizeSent(); if (epValue > 0) { avgSizeSent = (avgSizeSent == 0 ? epValue : (avgSizeSent + epValue) / 2); } } return avgSizeSent; } else { return avgSizeSent; } } // --- MessageLevelMetricsCollector methods --- public void resetStatistics() { messagesReceived = 0; faultsReceiving = 0; timeoutsReceiving = 0; bytesReceived = 0; minSizeReceived = 0; maxSizeReceived = 0; avgSizeReceived = 0; receivingFaultTable.clear(); messagesSent = 0; faultsSending = 0; timeoutsSending = 0; bytesSent = 0; minSizeSent = 0; maxSizeSent = 0; avgSizeSent = 0; sendingFaultTable.clear(); responseCodeTable.clear(); lastResetTime = System.currentTimeMillis(); if (endpoint.getChildren() != null) { for (Endpoint e : endpoint.getChildren()) { if (e.getMetricsMBean() != null) { e.getMetricsMBean().resetStatistics(); } } } log.info("Endpoint statistics reset for : " + endpointName + " (and/or its children)"); } public synchronized void incrementMessagesReceived() { messagesReceived++; } public synchronized void incrementFaultsReceiving(int errorCode) { faultsReceiving++; Object o = receivingFaultTable.get(errorCode); if (o == null) { receivingFaultTable.put(errorCode, ONE); } else { receivingFaultTable.put(errorCode, (Long) o + 1); } } public synchronized void incrementTimeoutsReceiving() { timeoutsReceiving++; } public synchronized void incrementBytesReceived(long size) { bytesReceived += size; } public synchronized void incrementMessagesSent() { messagesSent++; } public synchronized void incrementFaultsSending(int errorCode) { faultsSending++; Object o = sendingFaultTable.get(errorCode); if (o == null) { sendingFaultTable.put(errorCode, ONE); } else { sendingFaultTable.put(errorCode, (Long) o + 1); } } public synchronized void incrementTimeoutsSending() { timeoutsSending++; } public synchronized void incrementBytesSent(long size) { bytesSent += size; } public synchronized void notifyReceivedMessageSize(long size) { if (minSizeReceived == 0 || size < minSizeReceived) { minSizeReceived = size; } if (size > maxSizeReceived) { maxSizeReceived = size; } avgSizeReceived = (avgSizeReceived == 0 ? size : (avgSizeReceived + size) / 2); } public synchronized void notifySentMessageSize(long size) { if (minSizeSent == 0 || size < minSizeSent) { minSizeSent = size; } if (size > maxSizeSent) { maxSizeSent = size; } avgSizeSent = (avgSizeSent == 0 ? size : (avgSizeSent + size) / 2); } /** * Report a/an [typically non-fatal] error to the sending fault table, without incrementing * the sendingFault count e.g. to report a successful fail-over etc * @param errorCode the code to report */ public void reportSendingFault(int errorCode) { synchronized (sendingFaultTable) { Object o = sendingFaultTable.get(errorCode); if (o == null) { sendingFaultTable.put(errorCode, ONE); } else { sendingFaultTable.put(errorCode, (Long) o + 1); } } } /** * Report a/an [typically non-fatal] error to the receiving fault table, without incrementing * the receivingFault count * @param errorCode the code to report */ public void reportReceivingFault(int errorCode) { synchronized (receivingFaultTable) { Object o = receivingFaultTable.get(errorCode); if (o == null) { receivingFaultTable.put(errorCode, ONE); } else { receivingFaultTable.put(errorCode, (Long) o + 1); } } } /** * Collect response code statistics * @param respCode response code */ public void reportResponseCode(int respCode) { synchronized (responseCodeTable) { Object o = responseCodeTable.get(respCode); if (o == null) { responseCodeTable.put(respCode, ONE); } else { responseCodeTable.put(respCode, (Long) o + 1); } } } //---------- utility methods --------------- private static void addTableMaps(Map<Integer, Long> t, Map<Integer, Long> s) { for (Map.Entry<Integer, Long> o : s.entrySet()) { if (t.containsKey(o.getKey())) { t.put(o.getKey(), o.getValue() + s.get(o.getKey())); } else { t.put(o.getKey(), s.get(o.getKey())); } } } /** * Is the endpoint considered to be in the given state? * @param state the state to consider * @return true if all endpoints in a group are of the given state, or if a leaf endpoint is in the given state */ public boolean isEndpointInState(int state) { if (endpoint.getChildren() != null) { int count = 0, total = 0; for (Endpoint e : endpoint.getChildren()) { if (e.getContext().isState(state)) { count++; } total++; } return count == total; } else if (endpoint.getContext() != null) { return endpoint.getContext().isState(state); } return false; } }