public void RemoveSignups(IList <PIPoint> piPoints)
{
if (_PIPipe != null)
{
_PIPipe.RemoveSignups(piPoints);
}
else
{
// Raise exception
}
}
public void TimeSeriesUpdatesTest()
{
// Construct a unique PI Point name
string pointNameFormat = $"TimeSeriesUpdateTestPoint{AFTime.Now}";
bool signupCompleted = false;
using (var myDataPipe = new PIDataPipe(AFDataPipeType.TimeSeries))
{
Output.WriteLine($"Create a PI Point on [{Settings.PIDataArchive}] with compression off.");
var points = Fixture.CreatePIPoints(pointNameFormat, 1, true);
try
{
Output.WriteLine($"Sign up for time-series updates on PI Point [{pointNameFormat}].");
myDataPipe.AddSignups(points.ToList());
signupCompleted = true;
var startTime = AFTime.Now.ToPIPrecision() + TimeSpan.FromDays(-1);
int eventCount = 1000;
int totalCount = 0;
// Send events to each PI Point, the event's value is calculated from the timestamp
Output.WriteLine($"Write {eventCount} events to the new PI Point.");
Fixture.SendTimeBasedPIEvents(startTime, eventCount, points.ToList());
// Checks if Update Events are retrieved a few times
Output.WriteLine($"Get the update events.");
var eventsRetrieved = new AFListResults <PIPoint, AFDataPipeEvent>();
AssertEventually.True(() =>
{
eventsRetrieved = myDataPipe.GetUpdateEvents(eventCount);
totalCount += eventsRetrieved.Count();
return(totalCount == eventCount);
},
TimeSpan.FromSeconds(60),
TimeSpan.FromSeconds(1),
$"Failed to retrieve {eventCount} update events, retrieved {totalCount} instead.");
Output.WriteLine("Retrieved update events successfully.");
}
finally
{
if (signupCompleted)
{
myDataPipe.RemoveSignups(points.ToList());
}
Output.WriteLine("Delete all newly created PI Points.");
Fixture.DeletePIPoints(pointNameFormat, Output);
}
}
}
private void SubscribeToPointUpdates(MeasurementKey[] keys)
{
OnStatusMessage(MessageLevel.Info, $"Subscribing to updates for {keys.Length} measurements...");
var query = from row in DataSource.Tables["ActiveMeasurements"].AsEnumerable()
from key in keys
where row["ID"].ToString() == key.ToString()
select new
{
Key = key,
AlternateTag = row["AlternateTag"].ToString(),
PointTag = row["PointTag"].ToString()
};
List <PIPoint> dataPoints = new List <PIPoint>();
foreach (var row in query)
{
string tagName = row.PointTag;
if (!string.IsNullOrWhiteSpace(row.AlternateTag))
{
tagName = row.AlternateTag;
}
OnStatusMessage(MessageLevel.Debug, $"DEBUG: Looking up point tag '{tagName}'...");
PIPoint point = GetPIPoint(m_connection.Server, tagName);
if ((object)point != null)
{
OnStatusMessage(MessageLevel.Debug, $"DEBUG: Found point tag '{tagName}'...");
dataPoints.Add(point);
m_tagKeyMap[point.ID] = row.Key;
}
else
{
OnStatusMessage(MessageLevel.Debug, $"DEBUG: Failed to find point tag '{tagName}'...");
}
}
// Remove sign-ups for any existing point list
if ((object)m_dataPoints != null)
{
m_dataPipe.RemoveSignups(m_dataPoints);
}
// Sign up for updates on selected points
AFListResults <PIPoint, AFDataPipeEvent> initialEvents = m_dataPipe.AddSignupsWithInitEvents(dataPoints);
OnStatusMessage(MessageLevel.Debug, $"DEBUG: Initial event count = {initialEvents.Results.Count}...");
foreach (AFDataPipeEvent item in initialEvents.Results)
{
OnStatusMessage(MessageLevel.Debug, "DEBUG: Found initial event for action...");
if (item.Action != AFDataPipeAction.Delete)
{
m_dataUpdateObserver_DataUpdated(this, new EventArgs <AFValue>(item.Value));
}
}
m_dataPoints = dataPoints;
m_eventTimer.Enabled = true;
}
public void PIDataPipeTimeSeriesTest(PIPointType piPointType, object[] eventValues)
{
Contract.Requires(eventValues != null);
const string PointName = "PIDataPipeTests_PIPoint";
AFDatabase db = AFFixture.AFDatabase;
PIServer piServer = PIFixture.PIServer;
var piDataPipe = new PIDataPipe(AFDataPipeType.TimeSeries);
var piPointList = new PIPointList();
var now = AFTime.NowInWholeSeconds;
try
{
Output.WriteLine("Create the Future PI Points with Zero Compression and specified PI Point type.");
PIFixture.DeletePIPoints(PointName + "*", Output);
var testPIPoints = PIFixture.CreatePIPoints(PointName + "###", eventValues.Length, new Dictionary <string, object>
{
{ PICommonPointAttributes.PointType, piPointType },
{ PICommonPointAttributes.ExceptionDeviation, 0 },
{ PICommonPointAttributes.ExceptionMaximum, 0 },
{ PICommonPointAttributes.Compressing, 0 },
{ PICommonPointAttributes.DigitalSetName, "Phases" },
{ PICommonPointAttributes.Future, true },
});
Assert.True(testPIPoints.Count() == eventValues.Length, $"Unable to create all the test PI Points.");
piPointList.AddRange(testPIPoints);
// Add the PI Point as sign up to the PIDataPipe.
Output.WriteLine($"Sign up all PI Points with PIDataPipe.");
var afErrors = piDataPipe.AddSignups(piPointList);
var prefixErrorMessage = "Adding sign ups to the PIDataPipe was unsuccessful.";
Assert.True(afErrors == null,
userMessage: afErrors?.Errors.Aggregate(prefixErrorMessage, (msg, error) => msg += $" PI Point: [{error.Key.Name}] Error: [{error.Value.Message}] "));
// Write one data value to each PI Point.
var expectedAFValues = new AFValues();
for (int i = 0; i < eventValues.Length; i++)
{
AFValue afValue = null;
var timestamp = now + TimeSpan.FromMinutes(i - eventValues.Length);
// Special Handling of Input Data for Digital and Timestamp
switch (piPointType)
{
case PIPointType.Digital:
afValue = new AFValue(new AFEnumerationValue("Phases", (int)eventValues[i]), timestamp);
break;
case PIPointType.Timestamp:
afValue = new AFValue(new AFTime(eventValues[i], now), timestamp);
break;
default:
afValue = new AFValue(eventValues[i], timestamp);
break;
}
Output.WriteLine($"Writing Value [{eventValues[i]}] with Timestamp [{timestamp}] to PI Point [{piPointList[i].Name}].");
piPointList[i].UpdateValue(afValue, AFUpdateOption.InsertNoCompression);
// If writing digital states, we need to save the corresponding value for verification.
// Since we are using Phases, 0 ~ Phase1, 1 ~ Phase2, etc.
if (piPointType == PIPointType.Digital)
{
int input = (int)eventValues[i];
afValue = new AFValue(new AFEnumerationValue($"Phase{input + 1}", input), timestamp);
}
afValue.PIPoint = piPointList[i];
expectedAFValues.Add(afValue);
}
// Retry assert to retrieve expected Update Events from the PIDataPipe
var actualAFValues = new AFValues();
Output.WriteLine($"Reading Events from the PI DataPipe.");
AssertEventually.True(() =>
{
var updateEvents = piDataPipe.GetUpdateEvents(eventValues.Length);
prefixErrorMessage = "Retrieving Update Events from the PIDataPipe was unsuccessful.";
Assert.False(updateEvents.HasErrors,
userMessage: updateEvents.Errors?.Aggregate(prefixErrorMessage, (msg, error) => msg += $" PI Point: [{error.Key.Name}] Error: [{error.Value.Message}] "));
actualAFValues.AddRange(updateEvents.Results.Select(update => update.Value));
if (actualAFValues.Count >= expectedAFValues.Count)
{
// Verify that all expected update events are received from the PIDataPipe
Assert.True(expectedAFValues.Count == actualAFValues.Count, "PIDataPipe returned more events than expected. " +
$"Expected Count: {expectedAFValues.Count}, Actual Count: {actualAFValues.Count}.");
return(true);
}
return(false);
},
TimeSpan.FromSeconds(5),
TimeSpan.FromSeconds(0.5),
"Unable to retrieve events within the time frame.");
// Verify all received events.
Output.WriteLine($"Verifying all {actualAFValues.Count} events from the PI DataPipe.");
for (int i = 0; i < actualAFValues.Count; i++)
{
// Special handling of Output events for Timestamp
if (piPointType == PIPointType.Timestamp)
{
actualAFValues[i].Value = new AFTime(actualAFValues[i].Value, now);
}
AFFixture.CheckAFValue(actualAFValues[i], expectedAFValues[i]);
Assert.True(object.Equals(actualAFValues[i].PIPoint, expectedAFValues[i].PIPoint),
$"Unexpected PI Point Association. Expected: [{expectedAFValues[i].PIPoint}], Actual: [{actualAFValues[i].PIPoint}].");
}
// Remove all sign ups from the PIDataPipe
Output.WriteLine($"Remove all PI Point sign ups from PIDataPipe.");
afErrors = piDataPipe.RemoveSignups(piPointList);
prefixErrorMessage = "Removing sign ups to the PIDataPipe was unsuccessful.";
Assert.True(afErrors == null,
userMessage: afErrors?.Errors.Aggregate(prefixErrorMessage, (msg, error) => msg += $" PI Point: [{error.Key.Name}] Error: [{error.Value.Message}] "));
// Write dummy values to the PI Points and confirm PI DataPipe receives none.
Output.WriteLine($"Write dummy values to the PI Points.");
for (int i = 0; i < eventValues.Length; i++)
{
piPointList[i].UpdateValue(new AFValue(eventValues[i], now), AFUpdateOption.InsertNoCompression);
}
Output.WriteLine($"Verify no events are received by the PIDataPipe.");
var noEvents = piDataPipe.GetUpdateEvents(eventValues.Length);
prefixErrorMessage = "Retrieving Update Events from the PIDataPipe was unsuccessful.";
Assert.False(noEvents.HasErrors,
userMessage: noEvents.Errors?.Aggregate(prefixErrorMessage, (msg, error) => msg += $" PI Point: [{error.Key.Name}] Error: [{error.Value.Message}] "));
Assert.True(noEvents.Count == 0, "PIDataPipe received events even after removing all sign ups.");
}
finally
{
piDataPipe.RemoveSignups(piPointList);
piDataPipe.Dispose();
PIFixture.DeletePIPoints(PointName + "*", Output);
}
}