Author: ips Date: 2010-05-25 16:22:40 -0400 (Tue, 25 May 2010) New Revision: 941 Added: branches/EmbJopr_1_3/core/src/main/java/org/jboss/on/embedded/util/MeasurementConversionUtility.java Modified: branches/EmbJopr_1_3/core/src/main/java/org/jboss/on/embedded/bean/MeasurementIntegerValueAndUnits.java branches/EmbJopr_1_3/core/src/main/java/org/jboss/on/embedded/bean/MeasurementUtils.java branches/EmbJopr_1_3/core/src/main/java/org/jboss/on/embedded/bean/history/content/ContentServerServiceImpl.java branches/EmbJopr_1_3/jbas5/pom.xml branches/EmbJopr_1_3/pom.xml Log: update metric formatting code to compile against RHQ 3.0.0.B06 Modified: branches/EmbJopr_1_3/core/src/main/java/org/jboss/on/embedded/bean/MeasurementIntegerValueAndUnits.java =================================================================== --- branches/EmbJopr_1_3/core/src/main/java/org/jboss/on/embedded/bean/MeasurementIntegerValueAndUnits.java 2010-05-25 17:29:50 UTC (rev 940) +++ branches/EmbJopr_1_3/core/src/main/java/org/jboss/on/embedded/bean/MeasurementIntegerValueAndUnits.java 2010-05-25 20:22:40 UTC (rev 941) @@ -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: branches/EmbJopr_1_3/core/src/main/java/org/jboss/on/embedded/bean/MeasurementUtils.java =================================================================== --- branches/EmbJopr_1_3/core/src/main/java/org/jboss/on/embedded/bean/MeasurementUtils.java 2010-05-25 17:29:50 UTC (rev 940) +++ branches/EmbJopr_1_3/core/src/main/java/org/jboss/on/embedded/bean/MeasurementUtils.java 2010-05-25 20:22:40 UTC (rev 941) @@ -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: branches/EmbJopr_1_3/core/src/main/java/org/jboss/on/embedded/bean/history/content/ContentServerServiceImpl.java =================================================================== --- branches/EmbJopr_1_3/core/src/main/java/org/jboss/on/embedded/bean/history/content/ContentServerServiceImpl.java 2010-05-25 17:29:50 UTC (rev 940) +++ branches/EmbJopr_1_3/core/src/main/java/org/jboss/on/embedded/bean/history/content/ContentServerServiceImpl.java 2010-05-25 20:22:40 UTC (rev 941) @@ -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 + "..."); Copied: branches/EmbJopr_1_3/core/src/main/java/org/jboss/on/embedded/util/MeasurementConversionUtility.java (from rev 940, trunk/core/src/main/java/org/jboss/on/embedded/util/MeasurementConversionUtility.java) =================================================================== --- branches/EmbJopr_1_3/core/src/main/java/org/jboss/on/embedded/util/MeasurementConversionUtility.java (rev 0) +++ branches/EmbJopr_1_3/core/src/main/java/org/jboss/on/embedded/util/MeasurementConversionUtility.java 2010-05-25 20:22:40 UTC (rev 941) @@ -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: branches/EmbJopr_1_3/jbas5/pom.xml =================================================================== --- branches/EmbJopr_1_3/jbas5/pom.xml 2010-05-25 17:29:50 UTC (rev 940) +++ branches/EmbJopr_1_3/jbas5/pom.xml 2010-05-25 20:22:40 UTC (rev 941) @@ -11,18 +11,18 @@ <groupId>org.jboss.jopr</groupId> <artifactId>jopr-embedded-jbas5</artifactId> <packaging>war</packaging> - <name>JBossAS 5.x Administration Console</name> + <name>JBoss AS/EAP 5.x Administration Console</name> <scm> - <connection>scm:svn:http://anonsvn.jboss.org/repos/embjopr/branches/Emb... - <developerConnection>scm:svn:https://svn.jboss.org/repos/embjopr/branch... + <connection>scm:svn:http://anonsvn.jboss.org/repos/embjopr/branches/Emb... + <developerConnection>scm:svn:https://svn.jboss.org/repos/embjopr/branch... </scm> <properties> <warDir>${basedir}/target/${project.build.finalName}</warDir> <warFile>${warDir}.war</warFile> <contextRoot>admin-console</contextRoot> - <product.name>JBoss AS Admin Console</product.name> + <product.name>JBoss EAP Admin Console</product.name> </properties> <dependencies> @@ -41,7 +41,6 @@ <plugins> <plugin> <artifactId>maven-dependency-plugin</artifactId> - <version>2.0</version> <executions> <execution> <id>copy-dist-plugins</id> @@ -77,7 +76,13 @@ <groupId>${jopr.groupId}</groupId> <artifactId>jopr-jboss-cache-v3-plugin</artifactId> <version>${jopr.version}</version> - </artifactItem> + </artifactItem> + + <artifactItem> + <groupId>org.hornetq</groupId> + <artifactId>hornetq-jopr-plugin</artifactId> + <version>1.0.0.BETA1</version> + </artifactItem> </artifactItems> </configuration> </execution> @@ -98,7 +103,7 @@ <overlays> <overlay> <!-- empty groupId/artifactId detected as the current build. - earlier overlays win over later overlays, so put ourselves first. --> + earlier overlays win over later overlays, so put ourselves first. --> </overlay> <overlay> <groupId>org.jboss.jopr</groupId> @@ -161,7 +166,6 @@ <plugin> <artifactId>maven-antrun-plugin</artifactId> - <version>1.1</version> <executions> <execution> @@ -218,3 +222,4 @@ </profiles> </project> + Modified: branches/EmbJopr_1_3/pom.xml =================================================================== --- branches/EmbJopr_1_3/pom.xml 2010-05-25 17:29:50 UTC (rev 940) +++ branches/EmbJopr_1_3/pom.xml 2010-05-25 20:22:40 UTC (rev 941) @@ -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> @@ -54,6 +54,7 @@ <url>https://jira.jboss.org/jira/browse/EMBJOPR</url> </issueManagement> + <properties> <jbas4.finalName>jbas4-admin-console</jbas4.finalName> <jbas5.finalName>jbas5-admin-console</jbas5.finalName> @@ -66,10 +67,10 @@ <!-- dependency versions --> <jaxb-api.version>2.1</jaxb-api.version> - <jaxb-impl.version>2.1.6</jaxb-impl.version> - <jopr.version>2.3.0.EmbJopr.1.3.0-4</jopr.version> + <jaxb-impl.version>2.1.6</jaxb-impl.version> <richfaces.version>3.3.0.GA</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> <!-- This is a special patched version of not-yet-released Facelets 1.1.15, @@ -77,6 +78,7 @@ (see https://jira.jboss.org/jira/browse/JBSEAM-3066) --> <facelets.version>1.1.15.B1</facelets.version> </properties> + <build> <plugins> @@ -159,6 +161,7 @@ </plugins> </build> + <modules> <module>core</module> <module>jbas4</module> @@ -166,49 +169,49 @@ <!--<module>jsfunit</module>--> </modules> + <repositories> + <!-- TODO: Do we still need this? --> <repository> - <id>jboss</id> - <name>JBoss Release Repository</name> - <url>http://repository.jboss.org/maven2/</url> - <snapshots> - <enabled>false</enabled> - </snapshots> + <id>jboss-old</id> + <name>JBoss Old</name> + <url>https://repository.jboss.org/maven2/</url> + <snapshots> + <enabled>false</enabled> + </snapshots> </repository> + <!-- for the RHQ jars --> <repository> - <id>jboss-snapshots</id> - <name>JBoss Snapshot Repository</name> - <url>http://snapshots.jboss.org/maven2/</url> - <snapshots> - <enabled>true</enabled> - </snapshots> + <id>jboss-releases</id> + <name>JBoss Releases</name> + <url>https://repository.jboss.org/nexus/content/repositories/releases/&... + <snapshots> + <enabled>false</enabled> + </snapshots> </repository> </repositories> - <pluginRepositories> - <pluginRepository> - <id>jboss</id> - <name>JBoss Release Repository</name> - <url>http://repository.jboss.org/maven2/</url> - <snapshots> - <enabled>false</enabled> - </snapshots> - </pluginRepository> + <distributionManagement> - <pluginRepository> - <id>jboss-snapshots</id> - <name>JBoss Snapshot Repository</name> - <url>http://snapshots.jboss.org/maven2/</url> - <snapshots> - <enabled>true</enabled> - </snapshots> - </pluginRepository> + <snapshotRepository> + <id>jboss-snapshots-repository</id> + <name>JBoss Snapshots Repository</name> + <url>https://repository.jboss.org/nexus/content/repositories/snapshots +/</url> + </snapshotRepository> - </pluginRepositories> + <repository> + <id>jboss-releases-repository</id> + <name>JBoss Releases Repository</name> + <url>https://repository.jboss.org/nexus/service/local/staging/deploy/m +aven2/</url> + </repository> + </distributionManagement> + </project>