/*
* Licensed to the Apache Software Foundation (ASF) under one or more contributor license
* agreements. See the NOTICE file distributed with this work for additional information regarding
* copyright ownership. The ASF licenses this file to You under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance with the License. You may obtain a
* copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*/
package org.apache.geode.management.internal.beans.stats;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.atomic.AtomicReference;
import org.apache.geode.distributed.internal.InternalDistributedSystem;
import org.apache.geode.i18n.LogWriterI18n;
import org.apache.geode.management.internal.FederationComponent;
import org.apache.geode.management.internal.ManagementConstants;
/**
*
*
*/
public class StatsAggregator {
private Map<String, Class<?>> typeMap;
private Map<String, AtomicReference<Number>> aggregateMap;
private LogWriterI18n logger;
public StatsAggregator(Map<String, Class<?>> typeMap) {
this.typeMap = typeMap;
this.aggregateMap = new HashMap<String, AtomicReference<Number>>();
this.logger = InternalDistributedSystem.getLoggerI18n();
initAggregateMap();
}
/**
* Initialize all counters to 0;
*/
private void initAggregateMap() {
Iterator<String> it = typeMap.keySet().iterator();
while (it.hasNext()) {
AtomicReference<Number> ref = null;
String attribute = it.next();
Class<?> classzz = typeMap.get(attribute);
if (classzz == Long.TYPE) {
ref = new AtomicReference<Number>(new Long(0L));
} else if (classzz == Integer.TYPE) {
ref = new AtomicReference<Number>(new Integer(0));
} else if (classzz == Float.TYPE) {
ref = new AtomicReference<Number>(new Float(0F));
} else if (classzz == Double.TYPE) {
ref = new AtomicReference<Number>(new Double(0D));
}
aggregateMap.put(attribute, ref);
}
}
public void aggregate(FederationComponent newComp, FederationComponent oldComp) {
Map<String, Object> newState = (newComp != null ? newComp.getObjectState() : null);
Map<String, Object> oldState;
if (oldComp != null && oldComp.getOldState().size() > 0) {
oldState = oldComp.getOldState();
} else {
oldState = (oldComp != null ? oldComp.getObjectState() : null);
}
String attribute = null;
try {
if (typeMap != null && !typeMap.isEmpty()) {
for (Map.Entry<String, Class<?>> typeEntry : typeMap.entrySet()) {
attribute = typeEntry.getKey();
Object newVal = newState != null ? newState.get(attribute) : null;
if (newVal != null) {
Object oldVal = null;
if (oldState != null) {
oldVal = oldState.get(attribute);
}
Class<?> classzz = typeEntry.getValue();
if (classzz == Long.TYPE) {
if (oldVal == null) {
oldVal = new Long(0L);
}
incLong(attribute, (Long) newVal, (Long) oldVal);
} else if (classzz == Integer.TYPE) {
if (oldVal == null) {
oldVal = new Integer(0);
}
incInt(attribute, (Integer) newVal, (Integer) oldVal);
} else if (classzz == Float.TYPE) {
if (oldVal == null) {
oldVal = new Float(0F);
}
incFloat(attribute, (Float) newVal, (Float) oldVal);
} else if (classzz == Double.TYPE) {
if (oldVal == null) {
oldVal = new Double(0D);
}
incDouble(attribute, (Double) newVal, (Double) oldVal);
}
} else if (oldState != null && newState == null) {
Object oldVal = oldState.get(attribute);
if (oldVal != null) {
Class<?> classzz = typeEntry.getValue();
if (classzz == Long.TYPE) {
decLong(attribute, (Long) oldVal);
} else if (classzz == Integer.TYPE) {
decInt(attribute, (Integer) oldVal);
} else if (classzz == Float.TYPE) {
decFloat(attribute, (Float) oldVal);
} else if (classzz == Double.TYPE) {
decDouble(attribute, (Double) oldVal);
}
}
}
}
}
} catch (Exception e) {
if (logger.fineEnabled()) {
logger.fine("Exception while processing attribute " + attribute);
logger.fine(e);
}
}
}
public Integer getIntValue(String attributeName) {
int val = aggregateMap.get(attributeName).get().intValue();
return val < 0 ? ManagementConstants.NOT_AVAILABLE_INT : val;
}
public Long getLongValue(String attributeName) {
long val = aggregateMap.get(attributeName).get().longValue();
return val < 0 ? ManagementConstants.NOT_AVAILABLE_LONG : val;
}
public Float getFloatValue(String attributeName) {
float val = aggregateMap.get(attributeName).get().floatValue();
return val < 0 ? ManagementConstants.NOT_AVAILABLE_FLOAT : val;
}
public Double getDoubleValue(String attributeName) {
double val = aggregateMap.get(attributeName).get().doubleValue();
return val < 0 ? ManagementConstants.NOT_AVAILABLE_DOUBLE : val;
}
public void incLong(String attributeName, Long newVal, Long oldVal) {
if (newVal.equals(oldVal)) {
return;
}
AtomicReference<Number> ar = aggregateMap.get(attributeName);
for (;;) {
Number expectedVal = ar.get();
Number curVal = expectedVal.longValue() + (newVal - oldVal);
if (ar.compareAndSet(expectedVal, curVal)) {
return;
}
}
}
public void incInt(String attributeName, Integer newVal, Integer oldVal) {
if (newVal.equals(oldVal)) {
return;
}
AtomicReference<Number> ar = aggregateMap.get(attributeName);
for (;;) {
Number expectedVal = ar.get();
Number curVal = expectedVal.intValue() + (newVal - oldVal);
if (ar.compareAndSet(expectedVal, curVal)) {
return;
}
}
}
public void incFloat(String attributeName, Float newVal, Float oldVal) {
if (newVal.equals(oldVal)) {
return;
}
AtomicReference<Number> ar = aggregateMap.get(attributeName);
for (;;) {
Number expectedVal = ar.get();
Number curVal = expectedVal.floatValue() + (newVal - oldVal);
if (ar.compareAndSet(expectedVal, curVal)) {
return;
}
}
}
public void incDouble(String attributeName, Double newVal, Double oldVal) {
if (newVal.equals(oldVal)) {
return;
}
AtomicReference<Number> ar = aggregateMap.get(attributeName);
for (;;) {
Number expectedVal = ar.get();
Number curVal = expectedVal.doubleValue() + (newVal - oldVal);
if (ar.compareAndSet(expectedVal, curVal)) {
return;
}
}
}
public void decLong(String attributeName, Long oldVal) {
if (oldVal == 0) {
return;
}
AtomicReference<Number> ar = aggregateMap.get(attributeName);
Number curVal;
for (;;) {
Number expectedVal = ar.get();
if (expectedVal.longValue() != 0) {
curVal = expectedVal.longValue() - oldVal;
} else {
return;
}
if (ar.compareAndSet(expectedVal, curVal)) {
return;
}
}
}
public void decInt(String attributeName, Integer oldVal) {
if (oldVal == 0) {
return;
}
AtomicReference<Number> ar = aggregateMap.get(attributeName);
Number curVal;
for (;;) {
Number expectedVal = ar.get();
if (expectedVal.intValue() != 0) {
curVal = expectedVal.intValue() - oldVal;
} else {
return;
}
if (ar.compareAndSet(expectedVal, curVal)) {
return;
}
}
}
public void decFloat(String attributeName, Float oldVal) {
if (oldVal == 0) {
return;
}
AtomicReference<Number> ar = aggregateMap.get(attributeName);
Number curVal;
for (;;) {
Number expectedVal = ar.get();
if (expectedVal.floatValue() != 0) {
curVal = expectedVal.floatValue() - oldVal;
} else {
return;
}
if (ar.compareAndSet(expectedVal, curVal)) {
return;
}
}
}
public void decDouble(String attributeName, Double oldVal) {
if (oldVal == 0) {
return;
}
AtomicReference<Number> ar = aggregateMap.get(attributeName);
Number curVal;
for (;;) {
Number expectedVal = ar.get();
if (expectedVal.doubleValue() != 0) {
curVal = expectedVal.doubleValue() - oldVal;
} else {
return;
}
if (ar.compareAndSet(expectedVal, curVal)) {
return;
}
}
}
}