rrdexporter.java

httptunnel.jar httptunnel java 源码

/* ============================================================
 * JRobin : Pure java implementation of RRDTool's functionality
 * ============================================================
 *
 * Project Info:  http://www.jrobin.org
 * Project Lead:  Sasa Markovic ([e-mail])
 *
 * Developers:    Sasa Markovic ([e-mail])
 *                Arne Vandamme ([e-mail])
 *
 * (C) Copyright 2003, by Sasa Markovic.
 *
 * This library 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 library 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
 * library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA 02111-1307, USA.
 */
package net.jumperz.ext.org.jrobin.graph;

import java.io.IOException;
import java.util.HashMap;
import java.util.ArrayList;

import net.jumperz.ext.org.jrobin.core.*;

/**
 * <p>RrdExporter takes care of calculating a reduced dataset based on a RrdExportDef.</p>
 *
 * @author Arne Vandamme ([e-mail])
 */
class RrdExporter
{
	private RrdExportDef def;
	private RrdOpener rrdOpener;

	protected int numRows, reducedNumRows;								// Actual number of rows in the data set
	protected long startTime, endTime;									// Exact (requested) start and end time
	protected long reducedStartTime, reducedEndTime, reducedStep;		// Reduced start and end time, with step for the reduced set

	protected long[] timestamps;
	protected Source[] sources;
	protected HashMap sourceIndex;

	RrdExporter( RrdExportDef def )
	{
		setRrdOpener( new RrdOpener( false, true ) );
		setExportDef( def );
	}

	RrdExporter( RrdExportDef def, RrdOpener rrdOpener )
	{
		setRrdOpener( rrdOpener );
		setExportDef( def );
	}

	void setExportDef( RrdExportDef def )
	{
		this.def 			= def;
	}

	void setRrdOpener( RrdOpener rrdOpener )
	{
		this.rrdOpener = rrdOpener;
	}

	/**
	 * Fetches and calculates all datasources requested.
	 *
	 * This method is NOT synchronized, but it is important that access to it is controlled
	 * manually.  This should only be an issue if you are using it for package access, since
	 * the public interface of RrdExport only uses the synchronized fetch method.
	 *
	 * @throws net.jumperz.ext.org.jrobin.core.RrdException Thrown in case of a JRobin specific error.
	 * @throws java.io.IOException Thrown in case of a I/O related error.
	 */
	protected void calculateSeries( int maxRows ) throws RrdException, IOException
	{
		FetchSourceList fetchSources;
		ValueExtractor ve;
		FetchSource src;
		String[] varList;

		fetchSources			= def.getFetchSources();
		fetchSources.setRrdOpener( rrdOpener );

		long finalEndTime 		= Long.MAX_VALUE;
		boolean changingEndTime = false;

		long startTime 			= def.getStartTime();
		long endTime			= def.getEndTime();
		changingEndTime			= (endTime == 0);
		numRows 				= maxRows;
		reducedNumRows			= maxRows;

		int numDefs				= def.getNumDefs();
		int numSdefs			= def.getNumSdefs();

		Cdef[] cdefList			= def.getCdefs();
		int numCdefs			= cdefList.length;

		Pdef[] pdefList			= def.getPdefs();
		int numPdefs			= pdefList.length;

		ExportData[] edata		= def.getExportData();
		int[] edefTs;
		Source[] edefList;
		if ( edata.length > 0 )
		{
			ArrayList tsList	= new ArrayList( 30 );
			ArrayList list		= new ArrayList( 30 );
			for ( int i = 0; i < edata.length; i++ )
			{
				Source[] esrc = edata[i].getSources();

				for ( int j = 0; j < esrc.length; j++ )
				{
					list.add( esrc[j] );
					tsList.add( new Integer(i) );
				}
			}
			edefTs				= new int[ tsList.size() ];
			for ( int i = 0; i < edefTs.length; i++ )
				edefTs[i]		= ((Integer) tsList.get(i)).intValue();
			edefList			= (Source[]) list.toArray( new Source[] {} );
		}
		else
		{
			edefTs				= new int[0];
			edefList			= new Source[0];
		}
		int numEdefs			= edefList.length;

		// Set up the array with all datasources (both Def, Cdef and Pdef)
		sources 				= new Source[ numDefs + numEdefs + numCdefs + numPdefs ];
		sourceIndex 			= new HashMap( numDefs + numEdefs + numCdefs + numPdefs );
		int tblPos				= 0;
		int vePos				= 0;

		ValueExtractor[] veList	= new ValueExtractor[ fetchSources.size() ];

		long requestedStep		= (long) (endTime - startTime) / maxRows;
		if ( requestedStep <= 0 ) requestedStep = 1;

		// Shift start and endTime
		int minReduceFactor 	= 1;
		long minStep 			= Integer.MAX_VALUE, maxStep = Integer.MIN_VALUE, vStartTime, vEndTime, fetchEndTime;

		// -- Open all fetch datasources
		if ( fetchSources.size() > 0 || numEdefs > 0 )
		{
			try
			{
				fetchSources.openAll();

				// Calculate the reduce data factor
				for ( int i = 0; i < fetchSources.size(); i++ )
				{
					src					= fetchSources.get( i );

					if ( changingEndTime )
					{
						endTime		= src.getLastSampleTime( startTime, endTime, def.getResolution() );

						if ( endTime < finalEndTime )
							finalEndTime = endTime;

						requestedStep = (long) (endTime - startTime) / maxRows;
						if ( requestedStep <= 0 ) requestedStep = 1;
					}

					// Calculate the step for data retrieval
					long[] steps		= src.getFetchStep( startTime, endTime, def.getResolution() );

					int reduceFactor	= (int) Math.ceil( (double) requestedStep / (double) steps[0] );
					steps[0]			= steps[0] * reduceFactor;

					if ( steps[0] < minStep )
					{
						minStep 		= steps[0];
						minReduceFactor = reduceFactor;
					}
					if ( steps[1] > maxStep )
						maxStep			= steps[1];
				}

				for ( int i = 0; i < edata.length; i++ )
				{
					long step = edata[i].getStep();

					int reduceFactor	= (int) Math.ceil( (double) requestedStep / (double) step );
					step				= step * reduceFactor;

					if ( step < minStep )
					{
						minStep 		= step;
						minReduceFactor = reduceFactor;
					}
					if ( step > maxStep )
						maxStep			= step;
				}

				vStartTime			= Util.normalize( startTime, minStep );
				vStartTime			= ( vStartTime > startTime ? vStartTime - minStep : vStartTime );

				if ( !changingEndTime )
				{
					vEndTime			= Util.normalize( endTime, minStep );
					vEndTime			= ( vEndTime < endTime ? vEndTime + minStep : vEndTime );
				}
				else
				{
					vEndTime			= Util.normalize( finalEndTime, minStep );
					vEndTime			= ( vEndTime < finalEndTime ? vEndTime + minStep : vEndTime );
				}

				// This is the actual end time for the reduced data set
				reducedEndTime			= vEndTime;
				reducedStartTime		= vStartTime;
				reducedStep				= minStep;
				reducedNumRows			= (int) ((reducedEndTime - reducedStartTime) / reducedStep) + 1;

				fetchEndTime			= Util.normalize( vEndTime, maxStep );
				fetchEndTime			= ( fetchEndTime < vEndTime ? vEndTime + maxStep : fetchEndTime );

				// Now move back to the first time greater than or equal to fetchEndTime, normalized on minStep
				vEndTime				= Util.normalize( fetchEndTime, minStep );
				vEndTime				= ( vEndTime < fetchEndTime ? vEndTime + minStep : vEndTime );

				// Calculate numRows in the end table
				numRows					= (int) ((vEndTime - vStartTime) / minStep) + 1;

				// Fetch the actual data
				for ( int i = 0; i < fetchSources.size(); i++ )
				{
					src					= fetchSources.get( i );

					// Fetch all required datasources
					ve 		= src.fetch( vStartTime, vEndTime, def.getResolution(), minReduceFactor );
					varList = ve.getNames();

					for (int j= 0; j < varList.length; j++) {
						sources[tblPos]	= new Def( varList[j], numRows, reducedNumRows );
						sourceIndex.put( varList[j], new Integer(tblPos++) );
					}

					veList[ vePos++ ] = ve;
				}
			}
			finally
			{
				// Release all datasources again
				fetchSources.releaseAll();
			}
		}
		else
		{
			// The range should be used exactly as specified
			minStep					= requestedStep;