Author: ips Date: 2010-05-25 13:29:50 -0400 (Tue, 25 May 2010) New Revision: 940 Added: trunk/core/src/main/java/org/jboss/on/embedded/util/MeasurementConversionUtility.java Modified: trunk/core/src/main/java/org/jboss/on/embedded/bean/MeasurementIntegerValueAndUnits.java trunk/core/src/main/java/org/jboss/on/embedded/bean/MeasurementUtils.java trunk/core/src/main/java/org/jboss/on/embedded/bean/history/content/ContentServerServiceImpl.java trunk/pom.xml Log: upgrade RHQ from 3.0.0.B05 to 3.0.0.B06 and fix resulting compile errors Modified: trunk/core/src/main/java/org/jboss/on/embedded/bean/MeasurementIntegerValueAndUnits.java =================================================================== --- trunk/core/src/main/java/org/jboss/on/embedded/bean/MeasurementIntegerValueAndUnits.java 2010-05-15 15:28:08 UTC (rev 939) +++ trunk/core/src/main/java/org/jboss/on/embedded/bean/MeasurementIntegerValueAndUnits.java 2010-05-25 17:29:50 UTC (rev 940) @@ -1,6 +1,6 @@ /* * Embedded Jopr Project - * Copyright (C) 2006-2009 Red Hat, Inc. + * Copyright (C) 2006-2010 Red Hat, Inc. * All rights reserved. * * This program is free software; you can redistribute it and/or modify @@ -19,9 +19,9 @@ */ package org.jboss.on.embedded.bean; +import org.jboss.on.embedded.util.MeasurementConversionUtility; import org.rhq.core.domain.measurement.MeasurementUnits; import org.rhq.core.domain.measurement.composite.MeasurementNumericValueAndUnits; -import org.rhq.core.server.MeasurementConverter; /** * A subclass of {@link MeasurementNumericValueAndUnits) that overrides toString() to display the value as an integer @@ -39,6 +39,6 @@ @Override public String toString() { - return MeasurementConverter.format(getValue(), getUnits(), true, 0, 0); + return MeasurementConversionUtility.format(getValue(), getUnits(), true, 0, 0); } } Modified: trunk/core/src/main/java/org/jboss/on/embedded/bean/MeasurementUtils.java =================================================================== --- trunk/core/src/main/java/org/jboss/on/embedded/bean/MeasurementUtils.java 2010-05-15 15:28:08 UTC (rev 939) +++ trunk/core/src/main/java/org/jboss/on/embedded/bean/MeasurementUtils.java 2010-05-25 17:29:50 UTC (rev 940) @@ -1,6 +1,6 @@ /* * Embedded Jopr Project - * Copyright (C) 2006-2009 Red Hat, Inc. + * Copyright (C) 2006-2010 Red Hat, Inc. * All rights reserved. * * This program is free software; you can redistribute it and/or modify @@ -26,6 +26,7 @@ import java.util.Map; import java.util.Set; +import org.jboss.on.embedded.util.MeasurementConversionUtility; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.rhq.core.clientapi.agent.measurement.MeasurementAgentService; @@ -37,7 +38,6 @@ import org.rhq.core.domain.measurement.composite.MeasurementNumericValueAndUnits; import org.rhq.core.domain.measurement.composite.MeasurementStringValueAndUnits; import org.rhq.core.domain.measurement.util.MeasurementConversionException; -import org.rhq.core.server.MeasurementConverter; import org.rhq.core.domain.resource.ResourceType; import org.rhq.core.pc.PluginContainer; @@ -206,13 +206,13 @@ if (units == MeasurementUnits.NONE) { Double dbl = Double.valueOf(dataValue); if (dataValue != dbl.intValue()) - dataValueAndUnits = MeasurementConverter.fit(dataValue, + dataValueAndUnits = MeasurementConversionUtility.fit(dataValue, units); else dataValueAndUnits = new MeasurementIntegerValueAndUnits( dataValue, units); } else - dataValueAndUnits = MeasurementConverter.fit(dataValue, + dataValueAndUnits = MeasurementConversionUtility.fit(dataValue, units); measurementDisplay .setMeasurementValueAndUnits(dataValueAndUnits); Modified: trunk/core/src/main/java/org/jboss/on/embedded/bean/history/content/ContentServerServiceImpl.java =================================================================== --- trunk/core/src/main/java/org/jboss/on/embedded/bean/history/content/ContentServerServiceImpl.java 2010-05-15 15:28:08 UTC (rev 939) +++ trunk/core/src/main/java/org/jboss/on/embedded/bean/history/content/ContentServerServiceImpl.java 2010-05-25 17:29:50 UTC (rev 940) @@ -126,6 +126,11 @@ historyBean.addContentHistory(report); } + public boolean preLoadRemoteContent(int i,org.rhq.core.domain.content.PackageDetailsKey pdk) + { + return true; + } + private long downloadPackageBits(PackageDetailsKey packageDetailsKey, OutputStream outputStream) { log.debug("Downloading package bits for " + packageDetailsKey + "..."); Added: trunk/core/src/main/java/org/jboss/on/embedded/util/MeasurementConversionUtility.java =================================================================== --- trunk/core/src/main/java/org/jboss/on/embedded/util/MeasurementConversionUtility.java (rev 0) +++ trunk/core/src/main/java/org/jboss/on/embedded/util/MeasurementConversionUtility.java 2010-05-25 17:29:50 UTC (rev 940) @@ -0,0 +1,356 @@ +/* + * Embedded Jopr Project + * Copyright (C) 2006-2010 Red Hat, Inc. + * All rights reserved. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as + * published by the Free Software Foundation; either version 2.1 of + * the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +package org.jboss.on.embedded.util; + +import java.text.NumberFormat; +import java.util.HashSet; +import java.util.Set; + +import org.rhq.core.domain.measurement.MeasurementSchedule; +import org.rhq.core.domain.measurement.MeasurementUnits; +import org.rhq.core.domain.measurement.composite.MeasurementNumericValueAndUnits; +import org.rhq.core.domain.measurement.util.MeasurementConversionException; + +/** + * This class is a copy of org.rhq.core.server.MeasurementConverter from the RHQ server-jar module. + */ +public class MeasurementConversionUtility { + private static final int MAX_PRECISION_DIGITS = 4; + private static final String NULL_OR_NAN_FORMATTED_VALUE = "--no data available--"; + + private static NumberFormat getDefaultNumberFormat() { + NumberFormat nf = NumberFormat.getNumberInstance(); + + nf.setMinimumFractionDigits(1); + nf.setMaximumFractionDigits(1); + + return nf; + } + + public static Double scale(MeasurementNumericValueAndUnits origin, MeasurementUnits targetUnits) + throws MeasurementConversionException { + MeasurementUnits originUnits = origin.getUnits(); + Double originValue = origin.getValue(); + + return originValue * MeasurementUnits.calculateOffset(originUnits, targetUnits); + } + + public static Double scale(Double origin, MeasurementUnits targetUnits) throws MeasurementConversionException { + boolean wasNegative = false; + if (origin < 0) { + wasNegative = true; + origin = -origin; + } + + MeasurementUnits baseUnit = targetUnits.getBaseUnits(); + MeasurementNumericValueAndUnits valueAndUnits = new MeasurementNumericValueAndUnits(origin, baseUnit); + + Double results = scale(valueAndUnits, targetUnits); + if (wasNegative) { + results = -results; + } + + return results; + } + + public static String format(String value, MeasurementUnits targetUnits) { + if (targetUnits == null) { + return value; + } else { + return value + targetUnits; + } + } + + /** + * Formats the given array of double values: determines the necessary precision such that when formatted, they are + * distinct and reasonable to look at. For example, for values { 1.45 1.46 1.47 1.48 1.49 } the desired precision is + * 2 - less precision loses significant digits, and more precision provides no added benefit. Max precision is + * bounded for presentation considerations. + * + * @param values the values to be formatted + * @param targetUnits the target units for the values + * @param bestFit whether or not to use a normalized scale for the family of units + * @return the formatted values + */ + public static String[] formatToSignificantPrecision(double[] values, MeasurementUnits targetUnits, boolean bestFit) { + if ((null == values) || (values.length == 0)) { + return null; + } + + MeasurementUnits originalUnits = targetUnits; + + /* + * in the overwhelming majority of cases, you're going to want to apply a bestFit + * to the passed data, but it's not required; it's perfectly possible to allow a + * list of doubles to be formatted without being fit, in which case the targetUnits + * will be part of the formatted display for each result element + */ + if (bestFit) { + // find bestFit units by taking the average + Double average = 0.0; + + for (int i = 0, sz = values.length; i < sz; i++) { + /* + * adding fractional amount iterative leads to greater + * error, but prevents overflow on large data sets + */ + average += (values[i] / sz); + } + + MeasurementNumericValueAndUnits fittedAverage = fit(average, targetUnits); + //noinspection UnnecessaryLocalVariable + MeasurementUnits fittedUnits = fittedAverage.getUnits(); + + /* + * and change the local reference to targetUnits, so that the same logic + * can be used both for the bestFit and non-bestFit computations + */ + targetUnits = fittedUnits; + } + + @SuppressWarnings("unused") + Set<String> existingStrings; // technically this *is* unused because + int precisionDigits = 0; + boolean scaleWithMorePrecision = true; + String[] results = new String[values.length]; + NumberFormat nf = getDefaultNumberFormat(); + + /* + * we scale at most to MAX_PRECISION_DIGITS to allow for presentation limits + * + * increase the maxPrecisionDigits in the while condition + * itself to ensure it gets done for every loop + */ + while (scaleWithMorePrecision && (++precisionDigits <= MAX_PRECISION_DIGITS)) { + /* + * make the assumption that we no longer need to scale beyond this iteration + */ + scaleWithMorePrecision = false; + + /* + * we need to record the uniquely formatted values so we can determine + */ + existingStrings = new HashSet<String>(); + nf.setMinimumFractionDigits(0); + nf.setMaximumFractionDigits(precisionDigits); + + Double[] scaledValues = new Double[values.length]; + + for (int i = 0; i < scaledValues.length; i++) { + /* + * For relative units apply the scale now, prior to the nf.format(), since we are not using format( Double...). + * Otherwise, apply standard multi-unit scaling. + */ + if (MeasurementUnits.Family.RELATIVE == originalUnits.getFamily()) { + scaledValues[i] = MeasurementUnits.scaleUp(values[i], originalUnits); + } else { + scaledValues[i] = scale(new MeasurementNumericValueAndUnits(values[i], originalUnits), targetUnits); + } + } + + for (int i = 0; i < results.length; i++) { + /* + * JUST get the formatted value, specifically DON'T tack on the formatted units yet; + * we do this to see how many units we'll have to scale to afterwards (outside this + * while loop) to make the array of values passed to us unique + */ + String formatted = nf.format(scaledValues[i]); + + /* + * check whether formatted value was in the set or not; if it was, we have to + * loop, but only if we're not not already at our maximum precision + */ + boolean wasNewElement = existingStrings.add(formatted); + + if ((!wasNewElement) && (precisionDigits < MAX_PRECISION_DIGITS)) { + scaleWithMorePrecision = true; + break; + } + + results[i] = formatted; + } + } + + /* + * we did the best we could in terms of trying to find a precision that adds the most + * uniqueness to the given set of values, NOW tack on the formatted value for the units + */ + for (int i = 0; i < results.length; i++) { + results[i] = format(results[i], targetUnits); + } + + return results; + } + + public static String format(Double value, MeasurementUnits targetUnits, boolean bestFit) { + return format(value, targetUnits, bestFit, null, null); + } + + public static String format(Double value, MeasurementUnits targetUnits, boolean bestFit, + Integer minimumFractionDigits, Integer maximumFractionDigits) { + if (value == null || Double.isNaN(value)) { + return NULL_OR_NAN_FORMATTED_VALUE; + } + if (bestFit) { + MeasurementNumericValueAndUnits valueAndUnits = fit(value, targetUnits); + + value = valueAndUnits.getValue(); + targetUnits = valueAndUnits.getUnits(); + } + + // apply relative scale at presentation time + if (MeasurementUnits.Family.RELATIVE == targetUnits.getFamily()) { + value = MeasurementUnits.scaleUp(value, targetUnits); + } + + NumberFormat numberFormat = getDefaultNumberFormat(); + if (null != minimumFractionDigits) { + numberFormat.setMinimumFractionDigits(minimumFractionDigits); + } + if (null != maximumFractionDigits) { + numberFormat.setMaximumFractionDigits(maximumFractionDigits); + } + String formatted = numberFormat.format(value); + + return format(formatted, targetUnits); + } + + public static String scaleAndFormat(Double origin, MeasurementSchedule targetSchedule, boolean bestFit) + throws MeasurementConversionException { + MeasurementUnits targetUnits = targetSchedule.getDefinition().getUnits(); + + return scaleAndFormat(origin, targetUnits, bestFit, null, null); + } + + public static String scaleAndFormat(Double origin, MeasurementUnits targetUnits, boolean bestFit) + throws MeasurementConversionException { + + return scaleAndFormat(origin, targetUnits, bestFit, null, null); + } + + public static String scaleAndFormat(Double origin, MeasurementUnits targetUnits, boolean bestFit, + Integer minimumFractionDigits, Integer maximumFractionDigits) throws MeasurementConversionException { + + MeasurementUnits baseUnits = targetUnits.getBaseUnits(); + MeasurementNumericValueAndUnits valueAndUnits = new MeasurementNumericValueAndUnits(origin, baseUnits); + Double scaledMagnitude = scale(valueAndUnits, targetUnits); + + return format(scaledMagnitude, targetUnits, bestFit); + } + + public static MeasurementNumericValueAndUnits fit(Double origin, MeasurementUnits units) { + return fit(origin, units, null, null); + } + + public static MeasurementNumericValueAndUnits fit(Double origin, MeasurementUnits units, MeasurementUnits lowUnits, + MeasurementUnits highUnits) { + + // work-around for the various Chart descendants not properly setting their units field; + if (null == units) { + return new MeasurementNumericValueAndUnits(origin, units); + } + + // by definition, absolutely specified units don't scale to anything + if ((MeasurementUnits.Family.ABSOLUTE == units.getFamily()) + || (MeasurementUnits.Family.DURATION == units.getFamily())) { + return new MeasurementNumericValueAndUnits(origin, units); + } + + // by definition relative-valued units are self-scaled (converted at formatting) + if (MeasurementUnits.Family.RELATIVE == units.getFamily()) { + return new MeasurementNumericValueAndUnits(origin, units); + } + + if (MeasurementUnits.Family.TEMPERATURE == units.getFamily()) { + return new MeasurementNumericValueAndUnits(origin, units); + } + + // if the magnitude is zero, the best-fit also will spin around forever since it won't change + if (Math.abs(origin) < 1e-9) { + return new MeasurementNumericValueAndUnits(origin, units); + } + + boolean wasNegative = false; + + if (origin < 0) { + wasNegative = true; + origin = -origin; + } + + MeasurementNumericValueAndUnits currentValueAndUnits; + MeasurementNumericValueAndUnits nextValueAndUnits = new MeasurementNumericValueAndUnits(origin, units); + + // first, make the value smaller if it's too big + int maxOrdinal = (highUnits != null) ? (highUnits.ordinal() + 1) : MeasurementUnits.values().length; + + do { + currentValueAndUnits = nextValueAndUnits; + + int nextOrdinal = currentValueAndUnits.getUnits().ordinal() + 1; + if (nextOrdinal == maxOrdinal) { + // we could theoretically get bigger, but we don't have any units to represent that + break; + } + + MeasurementUnits biggerUnits = MeasurementUnits.values()[nextOrdinal]; + if (biggerUnits.getFamily() != currentValueAndUnits.getUnits().getFamily()) { + // we're as big as we can get, break out of the loop so we can return + break; + } + + Double smallerValue = scale(currentValueAndUnits, biggerUnits); + + nextValueAndUnits = new MeasurementNumericValueAndUnits(smallerValue, biggerUnits); + } while (nextValueAndUnits.getValue() > 1.0); + + // next, make the value bigger if it's too small + int minOrdinal = (lowUnits != null) ? (lowUnits.ordinal() - 1) : -1; + + while (currentValueAndUnits.getValue() < 1.0) { + int nextOrdinal = currentValueAndUnits.getUnits().ordinal() - 1; + if (nextOrdinal == minOrdinal) { + // we could theoretically get smaller, but we don't have any units to represent that + break; + } + + MeasurementUnits smallerUnits = MeasurementUnits.values()[nextOrdinal]; + if (smallerUnits.getFamily() != currentValueAndUnits.getUnits().getFamily()) { + // we're as small as we can get, break out of the loop so we can return + break; + } + + Double biggerValue = scale(currentValueAndUnits, smallerUnits); + + nextValueAndUnits = new MeasurementNumericValueAndUnits(biggerValue, smallerUnits); + + currentValueAndUnits = nextValueAndUnits; + } + + if (wasNegative) { + return new MeasurementNumericValueAndUnits(-currentValueAndUnits.getValue(), currentValueAndUnits + .getUnits()); + } + + return currentValueAndUnits; + } + + private MeasurementConversionUtility() { + } +} Modified: trunk/pom.xml =================================================================== --- trunk/pom.xml 2010-05-15 15:28:08 UTC (rev 939) +++ trunk/pom.xml 2010-05-25 17:29:50 UTC (rev 940) @@ -28,7 +28,7 @@ <parent> <groupId>org.rhq</groupId> <artifactId>rhq-parent</artifactId> - <version>3.0.0.B05</version> + <version>3.0.0.B06</version> </parent> <groupId>org.jboss.jopr</groupId> @@ -72,7 +72,7 @@ <jaxb.version>2.1.9</jaxb.version> <jboss.web.version>3.0.0-beta-2</jboss.web.version> <richfaces.version>3.3.3.Final</richfaces.version> - <rhq.version>3.0.0.B05</rhq.version> + <rhq.version>3.0.0.B06</rhq.version> <jopr.version>${rhq.version}</jopr.version> <seam.version>2.1.0.SP1</seam.version> <seam.embedded.version>beta3.SP3</seam.embedded.version>