public void serializeReportIntervalsTelemetryStatus()
{
ReportDescription reportDescription = new ReportDescription();
reportDescription.addReport("specifierID", ReportName.TELEMETRY_STATUS, 0, DurationModifier.MINUTES);
reportDescription.addIntervalResourceStatus("specifierID", DateTime.UtcNow, 0, DurationModifier.SECONDS, "rid", 1, (float)1.0, DataQuality.qualityGoodNonSpecific,
true, false, (float)1.0, (float)2.0, (float)3.0, (float)4.0, (float)5.0, (float)6.0, (float)7.0, (float)8.0, (float)9.0,
(float)10.0, (float)11.0, (float)12.0, (float)13.0, (float)14.0, (float)15.0, (float)16.0);
oadrReportType report = reportDescription.generateReport("specifierID", DateTime.UtcNow);
string output = SerializeOadrObject.serializeOjbect(report, typeof(oadrReportType));
Assert.IsTrue(output.Contains("<oadrReportPayload"));
Assert.IsTrue(output.Contains("<oadrPayloadResourceStatus"));
}
/**********************************************************/
private void validateReportDescription(ReportDescription reportDescription, int numStatusDescription, int numDataDescriptions)
{
foreach (string reportSpecifierID in reportDescription.ReportSpecifierIDs)
{
oadrReportType report = reportDescription.generateReportDescription(reportSpecifierID);
if (report.reportName.Contains("STATUS"))
{
// each resource should add one status description
Assert.AreEqual(numStatusDescription, report.oadrReportDescription.Length);
}
else
{
// each resource should add 2 data descriptions
Assert.AreEqual(numDataDescriptions, report.oadrReportDescription.Length);
}
}
}
public void intervalsCleared()
{
ReportWrapper reportWrapper = new ReportWrapper("specifier1", ReportName.TELEMETRY_USAGE, 5, DurationModifier.HOURS);
DateTime start = DateTime.Now.ToUniversalTime();
start = start.AddMilliseconds(-start.Millisecond);
start = start.AddSeconds(-start.Second);
addIntervalResourceStatus(reportWrapper, "rid1", start, (float)3.0);
oadrReportType report = reportWrapper.generateReport("requestID");
Assert.IsTrue(report.intervals.Length == 1, "should have 1 interval");
report = reportWrapper.generateReport("requestID");
Assert.IsTrue(report.intervals == null, "intervals should be null when no payloads are added to report");
}
/******************************************************************************/
// must hold the lock before calling this function
private void displayRegisterdReport(oadrReportType reportType)
{
tvReportRequestPayload.Nodes.Clear();
foreach (oadrReportDescriptionType reportDescription in reportType.oadrReportDescription)
{
TreeNode treeNode = new TreeNode("RID: " + reportDescription.rID);
tvReportRequestPayload.Nodes.Add(treeNode);
if (reportDescription.marketContext != null)
{
treeNode.Nodes.Add("Market Context: " + reportDescription.marketContext);
}
if (reportDescription.itemBase != null)
{
treeNode.Nodes.Add("Type: " + reportDescription.itemBase.ToString());
}
treeNode.Nodes.Add("Reading Type: " + reportDescription.readingType.ToString());
treeNode.Nodes.Add("Report Type: " + reportDescription.reportType.ToString());
if (reportDescription.oadrSamplingRate != null)
{
TreeNode samplingNode = new TreeNode("Sampling rate");
treeNode.Nodes.Add(samplingNode);
samplingNode.Nodes.Add("Min Period: " + reportDescription.oadrSamplingRate.oadrMinPeriod);
samplingNode.Nodes.Add("Max Period: " + reportDescription.oadrSamplingRate.oadrMaxPeriod);
samplingNode.Nodes.Add("On Change: " + reportDescription.oadrSamplingRate.oadrOnChange.ToString());
}
}
/*foreach (SpecifierPayloadType specifierPayload in reportRequest.reportSpecifier.specifierPayload)
* {
* TreeNode treeNode = new TreeNode("RID: " + specifierPayload.rID);
* tvReportRequestPayload.Nodes.Add(treeNode);
*
* treeNode.Nodes.Add("Reading Type: " + specifierPayload.readingType);
* }*/
}
/**********************************************************/
public string createUpdateReport(string venID, string requestID, Dictionary <string, ReportWrapper> reports, string reportRequestID)
{
request = new oadrUpdateReportType();
request.requestID = requestID;
request.schemaVersion = "2.0b";
request.venID = venID;
request.oadrReport = new oadrReportType[reports.Count];
int index = 0;
foreach (ReportWrapper reportWrapper in reports.Values)
{
oadrReportType report = reportWrapper.generateReport(reportRequestID);
request.oadrReport[index++] = report;
}
return(serializeObject(request));
}
/**********************************************************/
public string createUpdateReport(string venID, string requestID, ReportDescription reportDescription, List <string> reportSpecifierIDs, DateTime dtstartUTC)
{
request = new oadrUpdateReportType();
request.requestID = requestID;
request.schemaVersion = "2.0b";
request.venID = venID;
request.oadrReport = new oadrReportType[reportSpecifierIDs.Count];
int index = 0;
foreach (string reportSpecifierID in reportSpecifierIDs)
{
oadrReportType report = reportDescription.generateReport(reportSpecifierID, dtstartUTC);
request.oadrReport[index++] = report;
}
return(serializeObject(request));
}
public void durationExists()
{
ReportWrapper reportWrapper = new ReportWrapper("specifier1", ReportName.TELEMETRY_USAGE, 5, DurationModifier.HOURS);
DateTime start = DateTime.Now.ToUniversalTime();
start = start.AddMilliseconds(-start.Millisecond);
start = start.AddSeconds(-start.Second);
addIntervalResourceStatus(reportWrapper, "rid1", start, (float)1.0);
addIntervalEnergy(reportWrapper, "rid2", start, (float)1234.0);
oadrReportType report = reportWrapper.generateReport("requestID");
string xml = SerializeOadrObject.serializeOjbect(report, report.GetType());
Console.Out.WriteLine(xml);
Assert.IsTrue(report.intervals[0].duration != null, "interval with 'interva' and 'point' data must have duration");
}
/**********************************************************/
public oadrReportType generateReportDescription(string reportRequestID = null)
{
oadrReportType report = new oadrReportType();
report.dtstart = null;
report.duration = m_reportDuration;
report.createdDateTime = DateTime.UtcNow;
report.reportName = m_reportName.MetaDataName;
// test harness bug: conformance rule 311 says reportRequestID should
// be populated with the reportRequestID from the request if the report
// is generated from a reportRequest (and not through the registration process)
// the test harness will fail the VEN if the reportRequestID is anything but 0
//if (reportRequestID != null)
// report.reportRequestID = reportRequestID;
//else
report.reportRequestID = "0";
report.reportSpecifierID = ReportSpecifierID;
oadrReportDescriptionType[] reportDescriptionsArray = new oadrReportDescriptionType[m_reportDescriptions.Count];
int index = 0;
foreach (oadrReportDescriptionType reportDescription in m_reportDescriptions.Values)
{
reportDescriptionsArray[index] = reportDescription;
index++;
}
report.oadrReportDescription = reportDescriptionsArray;
report.intervals = null;
return(report);
}
/**********************************************************/
public oadrReportType generateReportDescription(string reportSpeciferID)
{
oadrReportType report = _reports[reportSpeciferID];
ReportName reportName = _reportNames[reportSpeciferID];
Dictionary <string, oadrReportDescriptionType> reportDescriptionsDictionary;
report.dtstart = null;
// report.duration = null;
report.createdDateTime = DateTime.UtcNow;
report.reportName = reportName.MetaDataName;
try
{
reportDescriptionsDictionary = _reportDescriptions[reportSpeciferID];
}
catch (System.Collections.Generic.KeyNotFoundException)
{
// thre report does not have any descriptors
return(report);
}
oadrReportDescriptionType[] reportDescriptionsArray = new oadrReportDescriptionType[reportDescriptionsDictionary.Count];
int index = 0;
foreach (oadrReportDescriptionType reportDescription in reportDescriptionsDictionary.Values)
{
reportDescriptionsArray[index] = reportDescription;
index++;
}
report.oadrReportDescription = reportDescriptionsArray;
report.intervals = null;
return(report);
}
public void singleInterval()
{
ReportWrapper reportWrapper = new ReportWrapper("specifier1", ReportName.TELEMETRY_USAGE, 5, DurationModifier.HOURS);
DateTime start = DateTime.Now.ToUniversalTime();
start = start.AddMilliseconds(-start.Millisecond);
start = start.AddSeconds(-start.Second);
addIntervalResourceStatus(reportWrapper, "rid1", start, (float)1.0);
addIntervalResourceStatus(reportWrapper, "rid2", start, (float)2.0);
oadrReportType report = reportWrapper.generateReport("requestID");
Assert.IsTrue(report.dtstart.datetime == report.intervals[0].dtstart.datetime);
Assert.IsTrue(report.intervals.Length == 1, "data with same dtstart should be placed in a single interval");
string xml = SerializeOadrObject.serializeOjbect(report, report.GetType());
Console.Out.WriteLine(xml);
}
/**********************************************************************************/
private void doSendUpdateReport(oadrReportType report, oadrReportRequestType reportRequest)
{
UpdateReport updateReport;
lock (m_ven)
{
updateReport = m_ven.updateReport(RandomHex.instance().generateRandomHex(10), report, reportRequest.reportRequestID);
}
m_callbacks.processUpdateReport(updateReport);
// UpdatedReports can contain a CancelReport piggybacked message; process
// the message if it exists
// since the VTN is not expecting a cancelledReport response so we can't call processCancelReport(...) directly
if (updateReport.response.oadrCancelReport != null)
{
// cancel the report request
List <string> pendingReports = m_resources.addCancelReport(updateReport.response.oadrCancelReport);
// call the callback to update the UI
m_callbacks.processCancelReport(updateReport.response.oadrCancelReport);
}
}
/**********************************************************/
public string createRegisterReport(string requestID, string venID, ReportDescription reportDescription)
{
request = new oadrRegisterReportType();
request.schemaVersion = "2.0b";
request.requestID = requestID;
request.venID = venID;
request.oadrReport = new oadrReportType[reportDescription.NumReports];
int index = 0;
foreach (string reportSpecifierID in reportDescription.ReportSpecifierIDs)
{
oadrReportType report = reportDescription.generateReportDescription(reportSpecifierID);
request.oadrReport[index] = report;
index++;
}
return(serializeObject(request));
}
/**********************************************************/
private void lstRegisteredRequests_SelectedIndexChanged(object sender, EventArgs e)
{
MethodInvoker mi = new MethodInvoker(delegate
{
lock (this)
{
try
{
if (lstRegisteredRequests.SelectedItems.Count == 0)
{
return;
}
ListViewItem lvi = lstRegisteredRequests.SelectedItems[0];
oadrReportType reportType = m_registeredReports[lvi.SubItems[IND_REPORT_SPECIFIER_ID].Text];
displayRegisterdReport(reportType);
}
catch (Exception ex)
{
Logger.logException(ex);
}
}
});
// BeginInvoke only needs to be called if we're tyring to update the UI from
// a thread that did not create it
if (this.InvokeRequired)
{
this.BeginInvoke(mi);
}
else
{
mi.Invoke();
}
}
public void serializeReportIntervalsTelemetryUsage()
{
ReportDescription reportDescription = new ReportDescription();
reportDescription.addReport("specifierID", ReportName.TELEMETRY_USAGE, 0, DurationModifier.MINUTES);
int uid = reportDescription.addInterval("specifierID", DateTime.UtcNow, 0, DurationModifier.SECONDS);
reportDescription.addIntervalReportPayload("specifierID", uid, "rid", 1, (float)1.0, (float)22.3, DataQuality.qualityGoodNonSpecific);
reportDescription.addIntervalReportPayload("specifierID", uid, "rid2", 1, (float)1.0, (float)41.3, DataQuality.qualityGoodNonSpecific);
reportDescription.addIntervalReportPayload("specifierID", DateTime.UtcNow.AddMinutes(5), 0, DurationModifier.SECONDS, "rid3", 1, (float)1.0, (float)57.6, DataQuality.qualityGoodNonSpecific);
oadrReportType report = reportDescription.generateReport("specifierID", DateTime.UtcNow);
// check that the createdDateTime is properly set to the current time
Console.Out.WriteLine(DateTime.UtcNow - report.createdDateTime);
Assert.IsTrue((DateTime.UtcNow - report.createdDateTime).Seconds < 5);
string output = SerializeOadrObject.serializeOjbect(report, typeof(oadrReportType));
Assert.IsTrue(output.Contains("<oadrReportPayload"));
Assert.IsTrue(output.Contains("<payloadFloat"));
}
/**********************************************************/
public oadrReportType generateReport(string reportSpecifierID, DateTime dtstartUTC)
{
oadrReportType report = _reports[reportSpecifierID];
ReportName reportName = _reportNames[reportSpecifierID];
report.reportName = reportName.Name;
// save the duration and restore after generating the report
// the duration is only required when registering the report; it indicates
// the max history that is recorded, and the max time frame the can be included in a report
DurationPropType duraton = report.duration;
report.duration = null;
report.createdDateTime = DateTime.UtcNow;
List <IntervalType> reportIntervals;
try
{
reportIntervals = _reportIntervals[reportSpecifierID];
}
catch (System.Collections.Generic.KeyNotFoundException)
{
// the report does not have any descriptors
return(report);
}
// the dtstart of the report must match the dtstart of the first interval
report.dtstart = new dtstart();
report.dtstart.datetime = reportIntervals[0].dtstart.datetime;
IntervalType[] intervalsArray = new IntervalType[reportIntervals.Count];
int intervalIndex = 0;
foreach (IntervalType interval in reportIntervals)
{
intervalsArray[intervalIndex] = interval;
List <oadrReportPayloadType> reportIntervalPayloads = _reportIntervalPayloads[reportSpecifierID][intervalIndex];
interval.streamPayloadBase = new StreamPayloadBaseType[reportIntervalPayloads.Count];
int payloadIndex = 0;
foreach (oadrReportPayloadType reportPayload in reportIntervalPayloads)
{
interval.streamPayloadBase[payloadIndex] = reportPayload;
payloadIndex++;
}
reportIntervalPayloads.Clear();
intervalIndex++;
}
_reportIntervals.Remove(reportSpecifierID);
_reportIntervalPayloads.Remove(reportSpecifierID);
report.oadrReportDescription = null;
report.intervals = intervalsArray;
return(report);
}
