private void butDeleteIntervals_Click(object sender, EventArgs e)
{
if (Different.MessageQuestion("Удалить отмеченные интервалы?"))
{
using (_book.StartAtom("Удаление интервалов из журнала"))
{
var intervals = new List <ArchiveInterval>();
int n = 0;
var t = dataSet1.Tables["IntervalsTable"];
foreach (DataRow row in t.Rows)
{
try
{
if ((bool)row["Otm"])
{
var interval = new ArchiveInterval(IntervalType.Single, (DateTime)row["PeriodBegin"], (DateTime)row["PeriodEnd"], (string)row["IntervalName"]);
intervals.Add(interval);
n++;
}
}
catch { }
}
_book.AddEvent("Удаление интервалов", n + " интервалов");
using (_book.Start(30, 65))
_book.Archive.DeleteIntervals(_book.CodeAsProject, ReportType.Excel, intervals);
using (_book.Start(65))
UpdateIntervals();
_book.ShowError();
}
}
}
/// <summary>
/// UpdaterThread Thread
/// </summary>
private void Get(ArchiveInterval interval, URIDelegate URI, ReaderDelegate Reader,
Host host, IXenObject xenObject)
{
if (host == null)
{
return;
}
try
{
Session session = xenObject.Connection.Session;
if (session == null)
{
return;
}
using (Stream httpstream = HTTPHelper.GET(URI(session, host, interval, xenObject), xenObject.Connection, true))
{
using (XmlReader reader = XmlReader.Create(httpstream))
{
SetsAdded = new List <DataSet>();
while (reader.Read())
{
Reader(reader, xenObject);
}
}
}
}
catch (WebException)
{
}
catch (Exception e)
{
log.Debug(string.Format("ArchiveMaintainer: Get updates for {0}: {1} Failed.", xenObject is Host ? "Host" : "VM", xenObject != null ? xenObject.opaque_ref : Helper.NullOpaqueRef), e);
}
}
private long TimeFromInterval(ArchiveInterval interval)
{
switch (interval)
{
case ArchiveInterval.FiveSecond:
if (LastFiveSecondCollection != DateTime.MinValue)
{
return(TimeUtil.TicksToSecondsSince1970(LastFiveSecondCollection.Ticks - TicksInFiveSeconds));
}
break;
case ArchiveInterval.OneMinute:
if (LastOneMinuteCollection != DateTime.MinValue)
{
return(TimeUtil.TicksToSecondsSince1970(LastOneMinuteCollection.Ticks - TicksInOneMinute));
}
break;
case ArchiveInterval.OneHour:
if (LastOneHourCollection != DateTime.MinValue)
{
return(TimeUtil.TicksToSecondsSince1970(LastOneHourCollection.Ticks - TicksInOneHour));
}
break;
case ArchiveInterval.OneDay:
if (LastOneDayCollection != DateTime.MinValue)
{
return(TimeUtil.TicksToSecondsSince1970(LastOneDayCollection.Ticks - TicksInOneDay));
}
break;
}
return(0);
}
/// <summary>
/// UpdaterThread Thread
/// </summary>
private Uri UpdateUri(Session session, Host host, ArchiveInterval interval, IXenObject xo)
{
string query =
xo is Host?
string.Format(RrdHostUpdatesQuery, Uri.EscapeDataString(session.uuid), TimeFromInterval(interval), RrdCFAverage, ToSeconds(interval)) :
xo is VM?
string.Format(RrdVmUpdatesQuery, Uri.EscapeDataString(session.uuid), TimeFromInterval(interval), RrdCFAverage, ToSeconds(interval), Helpers.GetUuid(xo)) :
"";
return(BuildUri(host, RrdUpdatesPath, query));
}
private static Uri RrdsUri(Session session, Host host, ArchiveInterval interval, IXenObject xo)
{
string query =
xo is Host?
string.Format(RrdHostQuery, Uri.EscapeDataString(session.uuid)) :
xo is VM?
string.Format(RrdVmQuery, Uri.EscapeDataString(session.uuid), Helpers.GetUuid(xo)) :
"";
return(BuildUri(host, xo is Host ? RrdHostPath : RrdVmPath, query));
}
public static long ToTicks(ArchiveInterval interval)
{
switch (interval)
{
case ArchiveInterval.FiveSecond:
return(TicksInFiveSeconds);
case ArchiveInterval.OneMinute:
return(TicksInOneMinute);
case ArchiveInterval.OneHour:
return(TicksInOneHour);
default:
return(TicksInOneDay);
}
}
public TimeSpan GetArchiveSpan()
{
ArchiveInterval interval = GetCurrentLeftArchiveInterval();
if (interval == ArchiveInterval.FiveSecond)
{
return(TimeSpan.FromTicks(ArchiveMaintainer.TicksInTenMinutes));
}
if (interval == ArchiveInterval.OneMinute)
{
return(TimeSpan.FromTicks(ArchiveMaintainer.TicksInTwoHours));
}
if (interval == ArchiveInterval.OneHour)
{
return(TimeSpan.FromTicks(ArchiveMaintainer.TicksInSevenDays));
}
return(TimeSpan.FromTicks(ArchiveMaintainer.TicksInOneYear));
}
public static ArchiveInterval NextArchiveDown(ArchiveInterval current)
{
switch (current)
{
case ArchiveInterval.FiveSecond:
return(ArchiveInterval.None);
case ArchiveInterval.OneMinute:
return(ArchiveInterval.FiveSecond);
case ArchiveInterval.OneHour:
return(ArchiveInterval.OneMinute);
case ArchiveInterval.OneDay:
return(ArchiveInterval.OneHour);
default:
return(ArchiveInterval.None);
}
}
private static long ToSeconds(ArchiveInterval interval)
{
return(TimeUtil.TicksToSeconds(ToTicks(interval)));
}
public static long ToTicks(ArchiveInterval interval)
{
switch (interval)
{
case ArchiveInterval.FiveSecond:
return TicksInFiveSeconds;
case ArchiveInterval.OneMinute:
return TicksInOneMinute;
case ArchiveInterval.OneHour:
return TicksInOneHour;
default:
return TicksInOneDay;
}
}
protected override void OnDrawToBuffer(PaintEventArgs paintEventArgs)
{
Program.AssertOnEventThread();
Rectangle rect = new Rectangle(ScrollViewRectangle.Left, ScrollViewRectangle.Top, ScrollViewRectangle.Width - 1, ScrollViewRectangle.Height - 1);
paintEventArgs.Graphics.FillRectangle(Palette.PaperBrush, ScrollViewRectangle);
paintEventArgs.Graphics.DrawRectangle(SystemPens.ActiveBorder, rect);
if (ArchiveMaintainer == null || Axis == null)
{
return;
}
if (ArchiveMaintainer.LoadingInitialData)
{
paintEventArgs.Graphics.DrawString(Messages.GRAPH_LOADING, Palette.LabelFont, Palette.LabelBrush, ScrollViewRectangle.Left + 10, ScrollViewRectangle.Top + 10);
return;
}
DataTimeRange everything = Animating ? AnimateTimeRange : CurrentArchiveRange;
RectangleF clip = paintEventArgs.Graphics.ClipBounds;
paintEventArgs.Graphics.SetClip(rect);
foreach (DataSet set in ScrollWideArchive.Sets.ToArray())
{
if (!set.Draw || !DisplayedUuids.Contains(set.Uuid))
{
continue;
}
List <DataPoint> todraw;
ArchiveInterval current = ScrollViewLeftArchiveInterval;
ArchiveInterval currentwidth = ScrollViewWidthArchiveInterval;
if (current == currentwidth)
{
todraw = new List <DataPoint>(set.Points);
if (current != ArchiveInterval.FiveSecond)
{
if (todraw.Count > 0 && todraw[0].X < ScrollViewRight.Ticks)
{
todraw.InsertRange(0, GetFinerPoints(
set,
new DataTimeRange(todraw[0].X, ScrollViewRight.Ticks, XRange.Resolution),
current));
}
}
}
else // currentwidth must be a higer resolution archive
{
int setindex = ArchiveMaintainer.Archives[currentwidth].Sets.IndexOf(set);
todraw = new List <DataPoint>(ArchiveMaintainer.Archives[currentwidth].Sets[setindex].Points);
if (todraw.Count > 0)
{
set.MergePointCollection(set.BinaryChop(set.Points, new DataTimeRange(ScrollViewLeft.Ticks, todraw[todraw.Count - 1].X, GraphResolution.Ticks)), todraw);
}
}
set.RefreshCustomY(everything, todraw);
if (set.CustomYRange.ScaleMode == RangeScaleMode.Auto)
{
set.CustomYRange.Max = DataSet.GetMaxY(set.CurrentlyDisplayed);
set.CustomYRange.RoundToNearestPowerOf10();
}
}
Axis.DrawToBuffer(new DrawAxisNavArgs(paintEventArgs.Graphics, ScrollViewRectangle, new DataTimeRange(everything.Max, everything.Min, -BodgeSpacing(new TimeSpan(-everything.Delta)).Ticks), true));
foreach (DataSet set in ScrollWideArchive.Sets.ToArray())
{
if (!set.Draw || !DisplayedUuids.Contains(set.Uuid))
{
continue;
}
lock (Palette.PaletteLock)
{
using (var normalPen = Palette.CreatePen(set.Uuid, Palette.PEN_THICKNESS_NORMAL))
{
LineRenderer.Render(paintEventArgs.Graphics, ScrollViewRectangle, everything, set.CustomYRange, normalPen, null, set.CurrentlyDisplayed, false);
}
}
}
if (DataEventList != null)
{
DataEventList.RenderEvents(paintEventArgs.Graphics, everything, ScrollViewRectangle, 5);
}
paintEventArgs.Graphics.SetClip(clip);
long selectedleft = LongPoint.TranslateToScreen(new LongPoint(GraphLeft.Ticks, 1), everything, DataRange.UnitRange, new LongRectangle(ScrollViewRectangle)).X;
long selectedright = LongPoint.TranslateToScreen(new LongPoint(GraphRight.Ticks, 1), everything, DataRange.UnitRange, new LongRectangle(ScrollViewRectangle)).X;
paintEventArgs.Graphics.FillRectangle(Palette.ShadowRangeBrush, ScrollViewRectangle.Left, ScrollViewRectangle.Top, selectedleft - (ScrollViewRectangle.Left), ScrollViewRectangle.Height);
paintEventArgs.Graphics.FillRectangle(Palette.ShadowRangeBrush, selectedright, ScrollViewRectangle.Top, ScrollViewRectangle.Width + (ScrollViewRectangle.Left) - selectedright, ScrollViewRectangle.Height);
DrawGripper(paintEventArgs.Graphics, selectedright);
DrawGripper(paintEventArgs.Graphics, selectedleft);
}
public List<DataPoint> GetFinerPoints(DataSet set, DataTimeRange range, ArchiveInterval current)
{
return set.GetRange(range, ArchiveMaintainer.ToTicks(current), ArchiveMaintainer.ToTicks(ArchiveMaintainer.NextArchiveDown(current)));
}
private static long ToSeconds(ArchiveInterval interval)
{
return(ToTicks(interval) / TimeSpan.TicksPerSecond);
}
public List <DataPoint> GetFinerPoints(DataSet set, DataTimeRange range, ArchiveInterval current)
{
return(set.GetRange(range, ArchiveMaintainer.ToTicks(current), ArchiveMaintainer.ToTicks(ArchiveMaintainer.NextArchiveDown(current))));
}
protected override void OnDrawToBuffer(PaintEventArgs paintEventArgs)
{
Program.AssertOnEventThread();
Rectangle SlightlySmaller = GraphRectangle(paintEventArgs.ClipRectangle);
// Fill BG
paintEventArgs.Graphics.FillRectangle(Palette.PaperBrush, SlightlySmaller);
if (ArchiveMaintainer == null || DataKey == null || DataPlotNav == null)
{
return;
}
if (IsSelected)
{
Rectangle rect = Rectangle.Inflate(paintEventArgs.ClipRectangle, 1, 1);
paintEventArgs.Graphics.FillRectangle(Palette.GraphShadow, rect);
paintEventArgs.Graphics.FillRectangle(Palette.PaperBrush, SlightlySmaller);
}
// Draw Rectangle around graph area
paintEventArgs.Graphics.DrawRectangle(Palette.GridPen, SlightlySmaller);
if (ArchiveMaintainer.LoadingInitialData)
{
paintEventArgs.Graphics.DrawString(Messages.GRAPH_LOADING, Palette.LabelFont, Palette.LabelBrush, SlightlySmaller.Left + 10, SlightlySmaller.Top + 10);
return;
}
bool require_tools = true;
foreach (DataSetCollectionWrapper set in DataKey.CurrentKeys)
{
if (set.Sets[ArchiveInterval.FiveSecond].TypeString != "memory")
{
require_tools = false;
break;
}
}
if (require_tools && DataKey.CurrentKeys.Count > 0)
{
Rectangle messageRect = Rectangle.Inflate(SlightlySmaller, -10, -10);
paintEventArgs.Graphics.DrawString(Messages.GRAPH_NEEDS_TOOLS, Palette.LabelFont, Palette.LabelBrush,
messageRect);
return;
}
// Refresh all sets
foreach (DataSet set in DataPlotNav.CurrentArchive.Sets.ToArray())
{
if (!set.Draw || !DataKey.DataSourceUUIDsToShow.Contains(set.Uuid))
{
continue;
}
List <DataPoint> todraw;
ArchiveInterval current = DataPlotNav.GetCurrentLeftArchiveInterval();
ArchiveInterval currentwidth = DataPlotNav.GetCurrentWidthArchiveInterval();
if (current == currentwidth)
{
todraw = new List <DataPoint>(set.Points);
if (current != ArchiveInterval.FiveSecond)
{
if (todraw.Count > 0 && todraw[0].X < DataPlotNav.GraphRight.Ticks)
{
todraw.InsertRange(0, DataPlotNav.GetFinerPoints(
set,
new DataTimeRange(todraw[0].X, DataPlotNav.GraphRight.Ticks, DataPlotNav.XRange.Resolution),
current));
}
}
}
else // currentwidth must be a higer resolution archive
{
int setindex = ArchiveMaintainer.Archives[currentwidth].Sets.IndexOf(set);
todraw = new List <DataPoint>(ArchiveMaintainer.Archives[currentwidth].Sets[setindex].Points);
if (todraw.Count > 0)
{
set.MergePointCollection(set.BinaryChop(set.Points, new DataTimeRange(DataPlotNav.GraphLeft.Ticks, todraw[todraw.Count - 1].X, DataPlotNav.GraphResolution.Ticks)), todraw);
}
}
set.RefreshCustomY(DataPlotNav.XRange, todraw);
DataRange ymax = DataRange.UnitRange;
foreach (DataSetCollectionWrapper wrapper in DataKey.CurrentKeys)
{
if (wrapper.Sets.ContainsKey(current))
{
DataSet dataSet = wrapper.Sets[current];
if (!dataSet.Hide && dataSet.CustomYRange != null &&
dataSet.CustomYRange.Units == set.CustomYRange.Units)
{
ymax.ScaleMode = dataSet.CustomYRange.ScaleMode;
if (dataSet.CustomYRange.ScaleMode != RangeScaleMode.Auto)
{
if (dataSet.CustomYRange.Max > ymax.Max)
{
ymax = dataSet.CustomYRange;
}
}
else
{
double maxY = DataSet.GetMaxY(dataSet.BinaryChop(dataSet.CurrentlyDisplayed, DataPlotNav.XRange));
if (maxY < 1)
{
maxY = 1;
}
if (maxY >= ymax.Max)
{
ymax = dataSet.CustomYRange;
ymax.Max = maxY;
}
}
}
}
}
if (set.CustomYRange.ScaleMode == RangeScaleMode.Auto)
{
ymax.RoundToNearestPowerOf10();
}
foreach (DataSetCollectionWrapper wrapper in DataKey.CurrentKeys)
{
foreach (DataSet ds in wrapper.Sets.Values)
{
if (ds.Hide || ds.CustomYRange == null || ds.CustomYRange.Units != set.CustomYRange.Units)
{
continue;
}
ds.CustomYRange.Max = ymax.Max;
ds.CustomYRange.Min = ymax.Min;
ds.CustomYRange.Resolution = ymax.Resolution;
}
}
}
// Draw Axes
XAxis.DrawToBuffer(new DrawAxisXArgs(paintEventArgs.Graphics, SlightlySmaller, DataPlotNav != null ? DataPlotNav.XRange : DataTimeRange.MaxRange, ShowLabels));
YAxis.DrawToBuffer(new DrawAxisYArgs(paintEventArgs.Graphics, SlightlySmaller, SelectedYRange, ShowLabels));
// Draw Sets
DataSet[] sets_to_show = DataPlotNav.CurrentArchive.Sets.ToArray();
Array.Sort(sets_to_show);
Array.Reverse(sets_to_show);
foreach (DataSet set in sets_to_show)
{
if (!set.Draw || DataKey == null || !DataKey.DataSourceUUIDsToShow.Contains(set.Uuid))
{
continue;
}
lock (Palette.PaletteLock)
{
using (var thickPen = Palette.CreatePen(set.Uuid, Palette.PEN_THICKNESS_THICK))
{
using (var normalPen = Palette.CreatePen(set.Uuid, Palette.PEN_THICKNESS_NORMAL))
{
using (var shadowBrush = Palette.CreateBrush(set.Uuid))
{
LineRenderer.Render(paintEventArgs.Graphics, SlightlySmaller, DataPlotNav.XRange, set.CustomYRange ?? SelectedYRange, set.Selected ? thickPen : normalPen, shadowBrush, set.CurrentlyDisplayed, true);
}
}
}
}
}
if (DataEventList != null)
{
DataEventList.RenderEvents(paintEventArgs.Graphics, DataPlotNav.XRange, new Rectangle(SlightlySmaller.Left, SlightlySmaller.Top + 2, SlightlySmaller.Width, SlightlySmaller.Height - 2), 16);
}
SizeF labelsize = new SizeF(0, 0);
if (SelectedPoint != null && DataKey.SelectedDataSet != null)
{
string label = string.Format(string.Format("{0} - {1} = {2}", DataPlotNav.XRange.GetString(SelectedPoint.X + ArchiveMaintainer.ClientServerOffset.Ticks), DataKey.SelectedDataSet.Name,
SelectedPoint.Y >= 0 ? SelectedYRange.GetString(SelectedPoint.Y) : Messages.GRAPHS_NO_DATA));
labelsize = paintEventArgs.Graphics.MeasureString(label, Palette.LabelFont);
paintEventArgs.Graphics.DrawString(label, Palette.LabelFont, Palette.LabelBrush, SlightlySmaller.Right - labelsize.Width, SlightlySmaller.Top - (labelsize.Height + 1));
}
// Draw graph's name
if (DisplayName != String.Empty)
{
Rectangle rect = new Rectangle(SlightlySmaller.Location, SlightlySmaller.Size);
rect.Width -= Convert.ToInt32(labelsize.Width);
string nameLabel = DisplayName.Ellipsise(paintEventArgs.Graphics, rect, Palette.LabelFont);
SizeF nameLabelSize = paintEventArgs.Graphics.MeasureString(nameLabel, Palette.LabelFont);
paintEventArgs.Graphics.DrawString(nameLabel, Palette.LabelFont, Palette.LabelBrush, SlightlySmaller.Left, SlightlySmaller.Top - (nameLabelSize.Height + 1));
}
// Draw to screen
Refresh();
}
/// <summary>
/// UpdaterThread Thread
/// </summary>
private void GetUpdate(ArchiveInterval interval, Host host, IXenObject xo)
{
Get(interval, UpdateUri, RRD_Update_InspectCurrentNode, host, xo);
}
private long TimeFromInterval(ArchiveInterval interval)
{
switch (interval)
{
case ArchiveInterval.FiveSecond:
if (LastFiveSecondCollection != DateTime.MinValue)
return TimeUtil.TicksToSecondsSince1970(LastFiveSecondCollection.Ticks - TicksInFiveSeconds);
break;
case ArchiveInterval.OneMinute:
if (LastOneMinuteCollection != DateTime.MinValue)
return TimeUtil.TicksToSecondsSince1970(LastOneMinuteCollection.Ticks - TicksInOneMinute);
break;
case ArchiveInterval.OneHour:
if (LastOneHourCollection != DateTime.MinValue)
return TimeUtil.TicksToSecondsSince1970(LastOneHourCollection.Ticks - TicksInOneHour);
break;
case ArchiveInterval.OneDay:
if (LastOneDayCollection != DateTime.MinValue)
return TimeUtil.TicksToSecondsSince1970(LastOneDayCollection.Ticks - TicksInOneDay);
break;
}
return 0;
}
public static ArchiveInterval NextArchiveDown(ArchiveInterval current)
{
switch (current)
{
case ArchiveInterval.FiveSecond:
return ArchiveInterval.None;
case ArchiveInterval.OneMinute:
return ArchiveInterval.FiveSecond;
case ArchiveInterval.OneHour:
return ArchiveInterval.OneMinute;
case ArchiveInterval.OneDay:
return ArchiveInterval.OneHour;
default:
return ArchiveInterval.None;
}
}
/// <summary>
/// UpdaterThread Thread
/// </summary>
private void GetUpdate(ArchiveInterval interval, Host host, IXenObject xo)
{
Get(interval, UpdateUri, RRD_Update_InspectCurrentNode, host, xo);
}
/// <summary>
/// UpdaterThread Thread
/// </summary>
private void RRD_Full_InspectCurrentNode(XmlReader reader, IXenObject xmo)
{
if (reader.NodeType == XmlNodeType.Element)
{
LastNode = reader.Name;
if (LastNode == "row")
{
CurrentTime += CurrentInterval * StepSize * TicksInOneSecond;
ValueCount = 0;
}
}
if (reader.NodeType == XmlNodeType.EndElement)
{
LastNode = reader.Name;
if (LastNode == "rra")
{
if (BailOut)
{
BailOut = false;
return;
}
ArchiveInterval i = GetArchiveIntervalFromFiveSecs(CurrentInterval);
if (i != ArchiveInterval.None)
{
Archives[i].CopyLoad(SetsAdded);
}
foreach (DataSet set in SetsAdded)
{
set.Points.Clear();
}
BailOut = false;
}
}
if (reader.NodeType != XmlNodeType.Text)
{
return;
}
if (LastNode == "name")
{
string str = reader.ReadContentAsString();
string id = string.Format("{0}:{1}:{2}", xmo is Host ? "host" : "vm", Helpers.GetUuid(xmo), str);
SetsAdded.Add(DataSet.Create(id, xmo, true, str));
}
else if (LastNode == "step")
{
string str = reader.ReadContentAsString();
StepSize = long.Parse(str, CultureInfo.InvariantCulture);
}
else if (LastNode == "lastupdate")
{
string str = reader.ReadContentAsString();
EndTime = long.Parse(str, CultureInfo.InvariantCulture);
}
else if (LastNode == "pdp_per_row")
{
string str = reader.ReadContentAsString();
CurrentInterval = long.Parse(str, CultureInfo.InvariantCulture);
long modInterval = EndTime % (StepSize * CurrentInterval);
long stepCount = CurrentInterval == 1 ? FiveSecondsInTenMinutes // 120 * 5 seconds in 10 minutes
: CurrentInterval == 12 ? MinutesInTwoHours // 120 minutes in 2 hours
: CurrentInterval == 720 ? HoursInOneWeek // 168 hours in a week
: DaysInOneYear; // 366 days in a year
CurrentTime = new DateTime((((EndTime - modInterval) - (StepSize * CurrentInterval * stepCount)) * TimeSpan.TicksPerSecond) + TimeUtil.TicksBefore1970).ToLocalTime().Ticks;
}
else if (LastNode == "cf")
{
string str = reader.ReadContentAsString();
if (str != RrdCFAverage)
{
BailOut = true;
}
}
else if (LastNode == "v")
{
if (BailOut || SetsAdded.Count <= ValueCount)
{
return;
}
DataSet set = SetsAdded[ValueCount];
string str = reader.ReadContentAsString();
set.AddPoint(str, CurrentTime, SetsAdded);
ValueCount++;
}
}
private static Uri RrdsUri(Session session, Host host, ArchiveInterval interval, IXenObject xo)
{
string query =
xo is Host ?
string.Format(RrdHostQuery, Uri.EscapeDataString(session.uuid)) :
xo is VM ?
string.Format(RrdVmQuery, Uri.EscapeDataString(session.uuid), Helpers.GetUuid(xo)) :
"";
return BuildUri(host, xo is Host ? RrdHostPath : RrdVmPath, query);
}
/// <summary>
/// UpdaterThread Thread
/// </summary>
private Uri UpdateUri(Session session, Host host, ArchiveInterval interval, IXenObject xo)
{
string query =
xo is Host ?
string.Format(RrdHostUpdatesQuery, Uri.EscapeDataString(session.uuid), TimeFromInterval(interval), RrdCFAverage, ToSeconds(interval)) :
xo is VM ?
string.Format(RrdVmUpdatesQuery, Uri.EscapeDataString(session.uuid), TimeFromInterval(interval), RrdCFAverage, ToSeconds(interval), Helpers.GetUuid(xo)) :
"";
return BuildUri(host, RrdUpdatesPath, query);
}
/// <summary>
/// UpdaterThread Thread
/// </summary>
private void Get(ArchiveInterval interval, URIDelegate URI, ReaderDelegate Reader,
Host host, IXenObject xenObject)
{
if (host == null)
return;
try
{
Session session = xenObject.Connection.Session;
if (session == null)
return;
using (Stream httpstream = HTTPHelper.GET(URI(session, host, interval, xenObject), xenObject.Connection, true, false))
{
using (XmlReader reader = XmlReader.Create(httpstream))
{
SetsAdded = new List<DataSet>();
while (reader.Read())
{
Reader(reader, xenObject);
}
}
}
}
catch (WebException)
{
}
catch (Exception e)
{
log.Debug(string.Format("ArchiveMaintainer: Get updates for {0}: {1} Failed.", xenObject is Host ? "Host" : "VM", xenObject != null ? xenObject.opaque_ref : Helper.NullOpaqueRef), e);
}
}
private static long ToSeconds(ArchiveInterval interval)
{
return TimeUtil.TicksToSeconds(ToTicks(interval));
}
private bool IsTimerAlive(ArchiveInterval interval)
{
_timers.TryGetValue(interval, out var timer);
return(timer != null);
}
