voldemort.store.stats.ClusterWideCounter.java Source code

Introduction

Here is the source code for voldemort.store.stats.ClusterWideCounter.java

Source

/*
 * Copyright 2008-2010 LinkedIn, Inc
 *
 * Licensed 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 voldemort.store.stats;

import com.google.common.collect.Maps;
import org.apache.log4j.Logger;
import voldemort.VoldemortException;
import voldemort.cluster.Cluster;
import voldemort.cluster.Node;

import java.util.Collections;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicLong;

/**
 * A thread-safe counter, that tracks per-node statistics and allows aggregation
 * by node and zone
 *
 */
public class ClusterWideCounter {

    private final static Logger logger = Logger.getLogger(ClusterWideCounter.class);

    private final Cluster cluster;
    private final ConcurrentMap<Integer, AtomicLong> values;

    public ClusterWideCounter(Cluster cluster) {
        this.cluster = cluster;
        this.values = new ConcurrentHashMap<Integer, AtomicLong>(cluster.getNumberOfNodes());
        for (Node node : cluster.getNodes())
            values.put(node.getId(), new AtomicLong(0L));
    }

    public void incrementCount(int nodeId) {
        AtomicLong counter = values.get(nodeId);
        if (counter == null) {
            counter = new AtomicLong(0L);
            values.putIfAbsent(nodeId, counter);
        }
        counter.incrementAndGet();
    }

    public void clearCount() {
        for (AtomicLong counter : values.values())
            counter.set(0L);
    }

    public void clearCount(int nodeId) {
        AtomicLong counter = values.get(nodeId);
        if (counter == null) {
            counter = new AtomicLong(0L);
            values.put(nodeId, counter);
        } else
            counter.set(0L);
    }

    public void setCount(int nodeId, Long newValue) {
        AtomicLong counter = values.get(nodeId);
        if (counter == null) {
            counter = new AtomicLong(0L);
            values.putIfAbsent(nodeId, counter);
        }
        counter.set(newValue);
    }

    public void setAll(Map<Integer, Long> newValues) {
        for (Map.Entry<Integer, Long> entry : newValues.entrySet())
            setCount(entry.getKey(), entry.getValue());
    }

    public Map<Integer, Long> asMap() {
        Map<Integer, Long> map = Maps.newHashMapWithExpectedSize(values.size());
        for (Map.Entry<Integer, AtomicLong> entry : values.entrySet())
            map.put(entry.getKey(), entry.getValue().get());
        return Collections.unmodifiableMap(map);
    }

    public Map<Integer, Long> byZone() {
        Map<Integer, Long> map = Maps.newHashMapWithExpectedSize(cluster.getNumberOfNodes());
        for (Map.Entry<Integer, AtomicLong> entry : values.entrySet()) {
            try {
                Node node = cluster.getNodeById(entry.getKey());
                int zoneId = node.getZoneId();
                Long count = map.get(zoneId);
                if (count == null)
                    count = 0L;
                count += entry.getValue().get();
                map.put(zoneId, count);
            } catch (VoldemortException e) {
                logger.warn("Can't get zone information for node id " + entry.getKey(), e);
            }
        }
        return Collections.unmodifiableMap(map);
    }

    public Long getCount(int nodeId) {
        AtomicLong counter = values.get(nodeId);
        if (counter == null)
            throw new IllegalArgumentException("no value for " + nodeId);
        return counter.get();
    }

    public Long getTotalCount() {
        long total = 0L;
        for (AtomicLong value : values.values())
            total += value.get();
        return total;
    }
}