domain/pools/ResourceMonitor.java

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident    "%Z%%M% %I% %E% SMI"
 */

package com.sun.solaris.domain.pools;

import java.math.BigInteger;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Iterator;
import com.sun.solaris.service.pools.Component;
import com.sun.solaris.service.pools.Resource;
import com.sun.solaris.service.pools.PoolsException;
import com.sun.solaris.service.pools.UnsignedInt64;

/**
 * This represents a monitored resource and the techniques used to
 * monitor the resource.
 */
class ResourceMonitor extends HashMap
{
    /**
     * The monitored resource.
     */
    private Resource target;

    /**
     * The size of the statistic buffer.
     */
    private final int maxSize;

    /**
     * Cached list of components to be monitored.
     */
    private LinkedList compList;

    /**
     * Constructor. No monitor target and a default buffer size of
     * 50.
     */
    public ResourceMonitor()
    {
        this(null, 50);
    }

    /**
     * Constructor.
     *
     * @param target The resource to be monitored.
     * @param maxSize The maximum number of samples to be held.
     */
    public ResourceMonitor(Resource target, int maxSize)
    {
        super();
        this.target = target;
        this.maxSize = maxSize;
        compList = new LinkedList();

    }

    /**
     * Initialize the resource monitor with it's list of
     * components. Components which are off-line or powered-off
     * cannot be monitored, so they should be removed from the
     * list of components.
     *
     * @throws PoolsException if there is an error accessing the
     * pool elements.
     */
    public void initialize() throws PoolsException
    {
        compList.clear();
        List candidates = target.getComponents(null);
        Iterator candIt = candidates.iterator();
        while (candIt.hasNext()) {
            Component comp = (Component) candIt.next();
            String status = comp.getStringProperty("cpu.status");
            if (status.compareTo("off-line") != 0 &&
                status.compareTo("powered-off") != 0)
                compList.add(comp);
        }
    }

    /**
     * Get the list of components which are actively monitored by
     * this resource.
     */
    public List getComponents()
    {
        return ((List) compList.clone());
    }

    /**
     * Return the maximum number of samples this monitor will
     * hold.
     */
    public int getMaxSampleSize()
    {
        return (maxSize);
    }

    /**
     * Return the object which is being monitored.
     */
    public Resource getMonitored()
    {
        return (target);
    }

    /**
     * Set the resource to be monitored. A resource target can
     * only be set once, if you attempt to modify it then an
     * IllegalArgumentException is thrown.
     *
     * @param target The resource to be monitored.
     * @throws IllegalArgumentException if the target has already
     * been set.
     */
    public void setResource(Resource target)
    {
        if (this.target != null)
            this.target = target;
        else
            throw new IllegalArgumentException("Once the target " +
                "of a ResourceMonitor is set, it cannot be " +
                "changed.");
    }

    /**
     * Return the name of the monitored object.
     *
     * @throws PoolsException if there is an error accessing the
     * pool element.
     */
    public String getName() throws PoolsException
    {
        String type = target.getStringProperty("type");
        return (target.getStringProperty(type + ".name"));
    }

    /**
     * Update the derived statistics.
     */
    public void updateDerived()
    {
        StatisticList util = (StatisticList) get("utilization");
        AggregateStatistic stat = calcDerivedStatistic("utilization");
        if (stat != null)
            util.add(stat);
    }

    /**
     * Get a derived statistic.
     *
     * @param name The name of the statistic to get.
     */
    public AggregateStatistic getDerivedStatistic(String name)
    {
        return ((AggregateStatistic)((StatisticList)get(name)).
            getLast());
    }

    /**
     * Return the latest value of a derived statistic.
     *
     * @param name is the name of the derived statistic to be
     * returned.
     */
    private AggregateStatistic calcDerivedStatistic(String name)
    {
        /*
         * The only statistic which can be obtained from this
         * resource monitor is utilization. A utilization
         * statistic actually represents a complex
         * manipulation of several lower level
         * statistics. This manipulation is performed here
         * until a good interface can be thought through which
         * best captures this abstraction.
         */
        if (name.compareTo("utilization") != 0)
            throw new IllegalArgumentException("No such derived "
                + "statistic: " + name);
        /*
         * This statistic is based on lower level
         * monotonically increasing numbers. The statistic can
         * thus only be derived as an observation of the
         * change in value over time of these values.
         */

        StatisticList first = (StatisticList) get("idle");

        switch (first.size()) {
        case 0:
        case 1:
            return (null);
        default:
            BigInteger total = new BigInteger("0");
            double utilV = 0.0;
            double idleV = 0.0;
            LinkedList keys = new LinkedList(keySet());
            keys.remove("utilization");
            for (int i = 0; i < keys.size(); i++) {
                StatisticList sl = (StatisticList) get(keys.
                    get(i));
                AggregateStatistic sv1 = (AggregateStatistic)
                    sl.getLast();
                AggregateStatistic sv2 = (AggregateStatistic)
                    sl.get(sl.size() - 2);
                if (sl.getName().compareTo("idle") == 0)
                    idleV = ((UnsignedInt64) sv1.
                        subtract(sv2).getValue()).
                        doubleValue();
                total = total.add((UnsignedInt64) sv1.
                    subtract(sv2).getValue());
            }
            utilV = 100 * ((total.doubleValue() - idleV) /
                total.doubleValue());
            return (new DoubleStatistic(new Double(utilV),
                ((AggregateStatistic)first.get(first.size() -
                2)).getStart(), ((AggregateStatistic)first.
                getLast()).getEnd()));
        }
    }

    void resetData(String name)
    {
        StatisticList sl = (StatisticList) get(name);
        sl.clear();
    }
}