public async Task ReadDisplayNames()
{
if (m_referenceDescriptions == null)
{
await BrowseFullAddressSpace(null).ConfigureAwait(false);
}
var nodeIds = m_referenceDescriptions.Select(n => ExpandedNodeId.ToNodeId(n.NodeId, m_session.NamespaceUris)).ToList();
if (m_operationLimits.MaxNodesPerRead > 0 &&
nodeIds.Count > m_operationLimits.MaxNodesPerRead)
{
var sre = Assert.Throws <ServiceResultException>(() => m_session.ReadDisplayName(nodeIds, out var displayNames, out var errors));
Assert.AreEqual(StatusCodes.BadTooManyOperations, sre.StatusCode);
while (nodeIds.Count > 0)
{
m_session.ReadDisplayName(nodeIds.Take((int)m_operationLimits.MaxNodesPerRead).ToArray(), out var displayNames, out var errors);
foreach (var name in displayNames)
{
TestContext.Out.WriteLine("{0}", name);
}
nodeIds = nodeIds.Skip((int)m_operationLimits.MaxNodesPerRead).ToList();
}
}
else
{
m_session.ReadDisplayName(nodeIds, out var displayNames, out var errors);
foreach (var name in displayNames)
{
TestContext.Out.WriteLine("{0}", name);
}
}
}
/// <summary>
/// Worker method to translate the browse path.
/// </summary>
public static BrowsePathResultCollection TranslateBrowsePathWorker(
IServerTestServices services,
ReferenceDescriptionCollection referenceDescriptions,
RequestHeader requestHeader,
OperationLimits operationLimits)
{
// Browse template
var startingNode = Objects.RootFolder;
requestHeader.Timestamp = DateTime.UtcNow;
// TranslateBrowsePath
bool verifyMaxNodesPerBrowse = operationLimits.MaxNodesPerTranslateBrowsePathsToNodeIds > 0;
var browsePaths = new BrowsePathCollection(
referenceDescriptions.Select(r => new BrowsePath()
{
RelativePath = new RelativePath(r.BrowseName), StartingNode = startingNode
})
);
BrowsePathResultCollection allBrowsePaths = new BrowsePathResultCollection();
while (browsePaths.Any())
{
if (verifyMaxNodesPerBrowse &&
browsePaths.Count > operationLimits.MaxNodesPerTranslateBrowsePathsToNodeIds)
{
verifyMaxNodesPerBrowse = false;
// Test if server responds with BadTooManyOperations
var sre = Assert.Throws <ServiceResultException>(() =>
_ = services.TranslateBrowsePathsToNodeIds(requestHeader, browsePaths, out var results, out var infos));
Assert.AreEqual(StatusCodes.BadTooManyOperations, sre.StatusCode);
}
var browsePathSnippet = (operationLimits.MaxNodesPerTranslateBrowsePathsToNodeIds > 0) ?
browsePaths.Take((int)operationLimits.MaxNodesPerTranslateBrowsePathsToNodeIds).ToArray() :
browsePaths;
ResponseHeader response = services.TranslateBrowsePathsToNodeIds(requestHeader, browsePathSnippet, out var browsePathResults, out var diagnosticInfos);
ServerFixtureUtils.ValidateResponse(response);
ServerFixtureUtils.ValidateDiagnosticInfos(diagnosticInfos, browsePathSnippet);
allBrowsePaths.AddRange(browsePathResults);
foreach (var result in browsePathResults)
{
if (result.Targets?.Count > 0)
{
TestContext.Out.WriteLine("BrowsePath {0}", result.Targets[0].ToString());
}
}
if (operationLimits.MaxNodesPerTranslateBrowsePathsToNodeIds == 0)
{
browsePaths.Clear();
}
else
{
browsePaths = browsePaths.Skip((int)operationLimits.MaxNodesPerTranslateBrowsePathsToNodeIds).ToArray();
}
}
return(allBrowsePaths);
}
public async Task BrowseAsync()
{
// Browse template
var startingNode = Objects.RootFolder;
var browseTemplate = new BrowseDescription {
NodeId = startingNode,
BrowseDirection = BrowseDirection.Forward,
ReferenceTypeId = ReferenceTypeIds.HierarchicalReferences,
IncludeSubtypes = true,
NodeClassMask = 0,
ResultMask = (uint)BrowseResultMask.All
};
var requestHeader = new RequestHeader();
var referenceDescriptions = new ReferenceDescriptionCollection();
var browseDescriptionCollection = ServerFixtureUtils.CreateBrowseDescriptionCollectionFromNodeId(
new NodeIdCollection(new NodeId[] { Objects.RootFolder }),
browseTemplate);
while (browseDescriptionCollection.Any())
{
TestContext.Out.WriteLine("Browse {0} Nodes...", browseDescriptionCollection.Count);
BrowseResultCollection allResults = new BrowseResultCollection();
var response = await Session.BrowseAsync(
requestHeader, null, 5,
browseDescriptionCollection,
CancellationToken.None).ConfigureAwait(false);
BrowseResultCollection results = response.Results;
DiagnosticInfoCollection diagnosticInfos = response.DiagnosticInfos;
allResults.AddRange(results);
var continuationPoints = ServerFixtureUtils.PrepareBrowseNext(results);
while (continuationPoints.Any())
{
TestContext.Out.WriteLine("BrowseNext {0} Nodes...", continuationPoints.Count);
var nextResponse = await Session.BrowseNextAsync(requestHeader, false, continuationPoints, CancellationToken.None);
BrowseResultCollection browseNextResultCollection = nextResponse.Results;
diagnosticInfos = nextResponse.DiagnosticInfos;
ServerFixtureUtils.ValidateResponse(response.ResponseHeader);
ServerFixtureUtils.ValidateDiagnosticInfos(diagnosticInfos, continuationPoints);
allResults.AddRange(browseNextResultCollection);
continuationPoints = ServerFixtureUtils.PrepareBrowseNext(browseNextResultCollection);
}
// Build browse request for next level
var browseTable = new NodeIdCollection();
foreach (var result in allResults)
{
referenceDescriptions.AddRange(result.References);
foreach (var reference in result.References)
{
browseTable.Add(ExpandedNodeId.ToNodeId(reference.NodeId, Session.NamespaceUris));
}
}
browseDescriptionCollection = ServerFixtureUtils.CreateBrowseDescriptionCollectionFromNodeId(browseTable, browseTemplate);
}
referenceDescriptions.Sort((x, y) => (x.NodeId.CompareTo(y.NodeId)));
// read values
var nodesToRead = new ReadValueIdCollection(referenceDescriptions.Select(r =>
new ReadValueId()
{
NodeId = ExpandedNodeId.ToNodeId(r.NodeId, Session.NamespaceUris),
AttributeId = Attributes.Value
}));
// test reads
TestContext.Out.WriteLine("Test Read Nodes...");
var readResponse = await Session.ReadAsync(requestHeader, 0, TimestampsToReturn.Neither, nodesToRead, CancellationToken.None).ConfigureAwait(false);
// test register nodes
TestContext.Out.WriteLine("Test Register Nodes...");
var nodesToRegister = new NodeIdCollection(nodesToRead.Select(n => n.NodeId));
var registerResponse = await Session.RegisterNodesAsync(requestHeader, nodesToRegister, CancellationToken.None).ConfigureAwait(false);
var unregisterResponse = await Session.UnregisterNodesAsync(requestHeader, registerResponse.RegisteredNodeIds, CancellationToken.None).ConfigureAwait(false);
// test writes
var nodesToWrite = new WriteValueCollection();
int ii = 0;
foreach (var result in readResponse.Results)
{
if (StatusCode.IsGood(result.StatusCode))
{
var writeValue = new WriteValue()
{
AttributeId = Attributes.Value,
NodeId = nodesToRead[ii].NodeId,
Value = new DataValue(result.WrappedValue)
};
nodesToWrite.Add(writeValue);
}
ii++;
}
TestContext.Out.WriteLine("Test Writes...");
var writeResponse = await Session.WriteAsync(requestHeader, nodesToWrite, CancellationToken.None).ConfigureAwait(false);
TestContext.Out.WriteLine("Found {0} references on server.", referenceDescriptions.Count);
ii = 0;
foreach (var reference in referenceDescriptions)
{
TestContext.Out.WriteLine("NodeId {0} {1} {2} {3}", reference.NodeId, reference.NodeClass, reference.BrowseName, readResponse.Results[ii++].WrappedValue);
}
}