/// <summary> /// <p>Creates new archive definition object. This object should be passed as argument to /// {@link RrdDef#AddArchive(ArcDef) AddArchive()} method of /// {@link RrdDb RrdDb} object.</p> /// <p/> /// <p>For the complete explanation of all archive definition parameters, see RRDTool's /// <a href="../../../../man/rrdcreate.html" target="man">rrdcreate man page</a></p> /// </summary> /// <param name="consolFun"> /// Consolidation function. Allowed values are "AVERAGE", "MIN", /// "MAX" and "LAST" (these string constants are conveniently defined in the /// {@link ConsolFuns} class). /// </param> /// <param name="xff">X-files factor, between 0 and 1.</param> /// <param name="steps">Number of archive steps.</param> /// <param name="rows">Number of archive rows</param> public ArcDef(ConsolidationFunction consolFun, double xff, int steps, int rows) { ConsolFun = consolFun; Xff = xff; Steps = steps; Rows = rows; Validate(); }
// Overrides the GetGrandTotalName method public override string GetGrandTotalName(ConsolidationFunction functionType) { // Checks the function type used to add the subtotals switch (functionType) { // Returns custom value based on the function type used to add the subtotals case ConsolidationFunction.Average: return "GRD AVG"; // Handle other cases as per requirement default: return base.GetGrandTotalName(functionType); } }
// Overrides the GetGrandTotalName method public override string GetGrandTotalName(ConsolidationFunction functionType) { // Checks the function type used to add the subtotals switch (functionType) { // Returns custom value based on the function type used to add the subtotals case ConsolidationFunction.Average: return("GRD AVG"); // Handle other cases as per requirement default: return(base.GetGrandTotalName(functionType)); } }
/// <summary> /// Returns single aggregated value for the give consolidation function /// </summary> /// <param name="consolFun">Consolidation Function</param> /// <returns>aggregated value</returns> public double GetAggregate(ConsolidationFunction consolFun) { switch (consolFun) { case ConsolidationFunction.AVERAGE: return Average; case ConsolidationFunction.MIN: return Min; case ConsolidationFunction.MAX: return Max; case ConsolidationFunction.LAST: return Last; case ConsolidationFunction.FIRST: return First; case ConsolidationFunction.TOTAL: return Total; default: throw new ArgumentOutOfRangeException("consolFun"); } }
public Def(String name, String rrdPath, String dsName, ConsolidationFunction consolFun):this(name, rrdPath, dsName, consolFun, null) { }
/// <summary> /// Checks if function argument represents valid consolidation function name. /// </summary> /// <param name="consolFun">Consolidation function name</param> /// <returns></returns> public static bool ValidConsolFun(ConsolidationFunction consolFun) { return CONSOL_FUNS.Any(cFun => cFun == consolFun); }
/// <summary> /// Returns single aggregated value from the fetched data for a single datasource. /// </summary> /// <param name="dsName">Datasource name</param> /// <param name="consolFun">Consolidation function to be applied to fetched datasource values.</param> /// <returns> /// MIN, MAX, LAST, FIRST, AVERAGE or TOTAL value calculated from the fetched data /// for the given datasource name /// </returns> public double GetAggregate(String dsName, ConsolidationFunction consolFun) { DataProcessor dp = CreateDataProcessor(null); return dp.GetAggregate(dsName, consolFun); }
public PrintText(String srcName, ConsolidationFunction consolFun, String text, bool includedInGraph):base(text) { this.srcName = srcName; this.consolFun = consolFun; this.includedInGraph = includedInGraph; }
/** * Creates a new (static) virtual datasource. The value of the datasource is constant. This value is * evaluated by applying the given consolidation function to another virtual datasource. * * @param name Source name * @param defName Other source name * @param consolFun Consolidation function to be applied to other datasource. */ public void datasource(String name, String defName, ConsolidationFunction consolFun) { sources.Add(new SDef(name, defName, consolFun)); }
/** * Creates new RRD file based on the existing one, but with a different * size (number of rows) for a single archive. The archive to be resized * is identified by its consolidation function and the number of steps. * * @param sourcePath Path to the source RRD file (will not be modified) * @param destPath Path to the new RRD file (will be created) * @param consolFun Consolidation function of the archive to be resized * @param numSteps Number of steps of the archive to be resized * @param newRows New archive size (number of archive rows) * @throws IOException Thrown in case of I/O error * @throws RrdException Thrown in case of JRobin specific error */ public static void ResizeArchive(String sourcePath, String destPath, ConsolidationFunction consolFun, int numSteps, int newRows) { if (Util.SameFilePath(sourcePath, destPath)) { throw new RrdException("Source and destination paths are the same"); } if (newRows < 2) { throw new RrdException("New arcihve size must be at least 2"); } using (RrdDb rrdSource = RrdDb.Open(sourcePath)) { RrdDef rrdDef = rrdSource.GetRrdDef(); ArcDef arcDef = rrdDef.FindArchive(consolFun, numSteps); if (arcDef.Rows != newRows) { arcDef.Rows = newRows; rrdDef.Path = destPath; using (RrdDb rrdDest = RrdDb.Create(rrdDef)) { rrdSource.CopyStateTo(rrdDest); } } } }
/// <summary> /// Sets single archive's X-files factor to a new value. /// </summary> /// <param name="sourcePath">Path to existing RRD file (will be updated)</param> /// <param name="consolFun">Consolidation function of the target archive</param> /// <param name="steps">Number of steps of the target archive</param> /// <param name="newXff">New X-files factor for the target archive</param> public static void SetArcXff(String sourcePath, ConsolidationFunction consolFun, int steps, double newXff) { using (RrdDb rrd = RrdDb.Open(sourcePath)) { Archive arc = rrd.GetArchive(consolFun, steps); arc.Xff = newXff; } }
/// <summary> /// Creates a new RRD file with one archive removed. RRD file is created based on the /// existing one (the original RRD file is not modified at all). All relevant data from /// the original RRD file is copied to the new one. /// </summary> /// <param name="sourcePath">path to a RRD file to import data from (will not be modified)</param> /// <param name="destPath">path to a new RRD file (will be created)</param> /// <param name="consolFun">Consolidation function of Archive which should be removed</param> /// <param name="steps">Number of steps for Archive which should be removed</param> public static void RemoveArchive(String sourcePath, String destPath, ConsolidationFunction consolFun, int steps) { if (Util.SameFilePath(sourcePath, destPath)) { throw new RrdException("Source and destination paths are the same"); } using (RrdDb rrdSource = RrdDb.Open(sourcePath)) { RrdDef rrdDef = rrdSource.GetRrdDef(); rrdDef.Path = destPath; rrdDef.RemoveArchive(consolFun, steps); using (RrdDb rrdDest = RrdDb.Create(rrdDef)) { rrdSource.CopyStateTo(rrdDest); } } }
public SDef(String name, String defName, ConsolidationFunction consolFun):base(name) { this.defName = defName; this.consolFun = consolFun; }
/// <summary> /// Returns aggregated value for a set of values calculated by applying an RPN expression to the /// fetched data. For example, if you have two datasources named <code>x</code> and <code>y</code> /// in this FetchData and you want to calculate MAX value of <code>(x+y)/2</code>code> use something like: /// <code>getRpnAggregate("x,y,+,2,/", "MAX");</code> /// </summary> /// <param name="rpnExpression">RRDTool-like RPN expression</param> /// <param name="consolFun">Consolidation function (MIN, MAX, LAST, FIRST, AVERAGE or TOTAL)</param> /// <returns></returns> public double GetRpnAggregate(String rpnExpression, ConsolidationFunction consolFun) { DataProcessor dataProcessor = CreateDataProcessor(rpnExpression); return dataProcessor.GetAggregate(RPN_SOURCE_NAME, consolFun); }
public double GetAggregate(String dsName, ConsolidationFunction consolFun, String rpnExpression) { // for backward compatibility rpnExpression = rpnExpression.Replace("value", dsName); return GetRpnAggregate(rpnExpression, consolFun); }
public Def(String name, String rrdPath, String dsName, ConsolidationFunction consolFun, String backend):base(name) { this.rrdPath = rrdPath; this.dsName = dsName; this.consolFun = consolFun; this.backend = backend; }
/** * Defines virtual datasource. This datasource can then be used * in other methods like {@link #datasource(String, String)} or * {@link #gprint(String, String, String)}. * * @param name Source name * @param rrdPath Path to RRD file * @param dsName Datasource name in the specified RRD file * @param consolFun Consolidation function (AVERAGE, MIN, MAX, LAST) * @param backend Backend to be used while fetching data from a RRD file. */ public void datasource(String name, String rrdPath, String dsName, ConsolidationFunction consolFun, String backend) { sources.Add(new Def(name, rrdPath, dsName, consolFun, backend)); }
/// <summary> /// Modifies existing RRD file, by resizing its chosen archive. The archive to be resized /// is identified by its consolidation function and the number of steps. /// </summary> /// <param name="sourcePath">Path to the RRD file (will be modified)</param> /// <param name="consolFun">Consolidation function of the archive to be resized</param> /// <param name="numSteps">Number of steps of the archive to be resized</param> /// <param name="newRows">New archive size (number of archive rows)</param> /// <param name="saveBackup">true, if backup of the original file should be created;false, otherwise</param> public static void ResizeArchive(String sourcePath, ConsolidationFunction consolFun, int numSteps, int newRows, bool saveBackup) { String destPath = Util.GetTmpFilename(); ResizeArchive(sourcePath, destPath, consolFun, numSteps, newRows); CopyFile(destPath, sourcePath, saveBackup); }
/** * This method does basically the same thing as {@link #print(String, String, String)}, * but the result is printed on the graph itself, below the chart area. * * @param srcName Virtual source name * @param consolFun Consolidation function to be applied to the source * @param format Format string (like "average = %10.3f %s") */ public void gprint(String srcName, ConsolidationFunction consolFun, String format) { comments.Add(new PrintText(srcName, consolFun, format, true)); }
/// <summary> /// Adds single archive definition by specifying its consolidation function, X-files factor, /// number of steps and rows. For the complete explanation of all archive /// definition parameters see RRDTool's /// <a href="../../../../man/rrdcreate.html" target="man">rrdcreate man page</a>.</p> /// </summary> /// <param name="consolFun">Consolidation function. </param> /// <param name="xff"> X-files factor. Valid values are between 0 and 1.</param> /// <param name="steps">Number of archive steps</param> /// <param name="rows">Number of archive rows</param> public void AddArchive(ConsolidationFunction consolFun, double xff, int steps, int rows) { AddArchive(new ArcDef(consolFun, xff, steps, rows)); }
public void RemoveArchive(ConsolidationFunction consolFun, int steps) { ArcDef arcDef = FindArchive(consolFun, steps); if (!arcDefs.Remove(arcDef)) { throw new RrdException("Could not remove archive " + consolFun + "/" + steps); } }
internal ArcDef FindArchive(ConsolidationFunction consolFun, int steps) { ArcDef result = arcDefs.SingleOrDefault(x => x.ConsolFun == consolFun && x.Steps == steps); if(result !=null) return result; throw new RrdException("Could not find archive " + consolFun + "/" + steps); }
// This function will return the grand total name public override String GetGrandTotalName(ConsolidationFunction functionType) { return("Chinese Grand Total - 可能的用法"); }
// This function will return the grand total name public override String GetGrandTotalName(ConsolidationFunction functionType) { return "Chinese Grand Total - 可能的用法"; }