/// <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 void GetOperationLimits()
{
var operationLimits = new OperationLimits()
{
MaxNodesPerRead = GetOperationLimitValue(VariableIds.Server_ServerCapabilities_OperationLimits_MaxNodesPerRead),
MaxNodesPerHistoryReadData = GetOperationLimitValue(VariableIds.Server_ServerCapabilities_OperationLimits_MaxNodesPerHistoryReadData),
MaxNodesPerHistoryReadEvents = GetOperationLimitValue(VariableIds.Server_ServerCapabilities_OperationLimits_MaxNodesPerHistoryReadEvents),
MaxNodesPerWrite = GetOperationLimitValue(VariableIds.Server_ServerCapabilities_OperationLimits_MaxNodesPerWrite),
MaxNodesPerHistoryUpdateData = GetOperationLimitValue(VariableIds.Server_ServerCapabilities_OperationLimits_MaxNodesPerHistoryUpdateData),
MaxNodesPerHistoryUpdateEvents = GetOperationLimitValue(VariableIds.Server_ServerCapabilities_OperationLimits_MaxNodesPerHistoryUpdateEvents),
MaxNodesPerBrowse = GetOperationLimitValue(VariableIds.Server_ServerCapabilities_OperationLimits_MaxNodesPerBrowse),
MaxMonitoredItemsPerCall = GetOperationLimitValue(VariableIds.Server_ServerCapabilities_OperationLimits_MaxMonitoredItemsPerCall),
MaxNodesPerNodeManagement = GetOperationLimitValue(VariableIds.Server_ServerCapabilities_OperationLimits_MaxNodesPerNodeManagement),
MaxNodesPerRegisterNodes = GetOperationLimitValue(VariableIds.Server_ServerCapabilities_OperationLimits_MaxNodesPerRegisterNodes),
MaxNodesPerTranslateBrowsePathsToNodeIds = GetOperationLimitValue(VariableIds.Server_ServerCapabilities_OperationLimits_MaxNodesPerTranslateBrowsePathsToNodeIds),
MaxNodesPerMethodCall = GetOperationLimitValue(VariableIds.Server_ServerCapabilities_OperationLimits_MaxNodesPerMethodCall)
};
OperationLimits = operationLimits;
}
/// <inheritdoc/>
public IApplicationConfigurationBuilderClientOptions SetClientOperationLimits(OperationLimits operationLimits)
{
ApplicationConfiguration.ClientConfiguration.OperationLimits = operationLimits;
return(this);
}
/// <inheritdoc/>
public IApplicationConfigurationBuilderServerOptions SetOperationLimits(OperationLimits operationLimits)
{
ApplicationConfiguration.ServerConfiguration.OperationLimits = operationLimits;
return(this);
}
/// <summary>
/// Worker function to browse the full address space of a server.
/// </summary>
/// <param name="services">The service interface.</param>
/// <param name="operationLimits">The operation limits.</param>
public static ReferenceDescriptionCollection BrowseFullAddressSpaceWorker(
IServerTestServices services,
RequestHeader requestHeader,
OperationLimits operationLimits = null,
BrowseDescription browseDescription = null)
{
operationLimits = operationLimits ?? new OperationLimits();
requestHeader.Timestamp = DateTime.UtcNow;
// Browse template
var startingNode = Objects.RootFolder;
var browseTemplate = browseDescription ?? new BrowseDescription {
NodeId = startingNode,
BrowseDirection = BrowseDirection.Forward,
ReferenceTypeId = ReferenceTypeIds.HierarchicalReferences,
IncludeSubtypes = true,
NodeClassMask = 0,
ResultMask = (uint)BrowseResultMask.All
};
var browseDescriptionCollection = ServerFixtureUtils.CreateBrowseDescriptionCollectionFromNodeId(
new NodeIdCollection(new NodeId[] { Objects.RootFolder }),
browseTemplate);
// Browse
ResponseHeader response = null;
uint requestedMaxReferencesPerNode = operationLimits.MaxNodesPerBrowse;
bool verifyMaxNodesPerBrowse = operationLimits.MaxNodesPerBrowse > 0;
var referenceDescriptions = new ReferenceDescriptionCollection();
// Test if server responds with BadNothingToDo
{
var sre = Assert.Throws <ServiceResultException>(() =>
_ = services.Browse(requestHeader, null,
0, browseDescriptionCollection.Take(0).ToArray(),
out var results, out var infos));
Assert.AreEqual(StatusCodes.BadNothingToDo, sre.StatusCode);
}
while (browseDescriptionCollection.Any())
{
BrowseResultCollection allResults = new BrowseResultCollection();
if (verifyMaxNodesPerBrowse &&
browseDescriptionCollection.Count > operationLimits.MaxNodesPerBrowse)
{
verifyMaxNodesPerBrowse = false;
// Test if server responds with BadTooManyOperations
var sre = Assert.Throws <ServiceResultException>(() =>
_ = services.Browse(requestHeader, null,
0, browseDescriptionCollection,
out var results, out var infos));
Assert.AreEqual(StatusCodes.BadTooManyOperations, sre.StatusCode);
// Test if server responds with BadTooManyOperations
var tempBrowsePath = browseDescriptionCollection.Take((int)operationLimits.MaxNodesPerBrowse + 1).ToArray();
sre = Assert.Throws <ServiceResultException>(() =>
_ = services.Browse(requestHeader, null,
0, tempBrowsePath,
out var results, out var infos));
Assert.AreEqual(StatusCodes.BadTooManyOperations, sre.StatusCode);
}
bool repeatBrowse;
var maxNodesPerBrowse = operationLimits.MaxNodesPerBrowse;
BrowseResultCollection browseResultCollection = new BrowseResultCollection();
DiagnosticInfoCollection diagnosticsInfoCollection;
do
{
var browseCollection = (maxNodesPerBrowse == 0) ?
browseDescriptionCollection :
browseDescriptionCollection.Take((int)maxNodesPerBrowse).ToArray();
repeatBrowse = false;
try
{
requestHeader.Timestamp = DateTime.UtcNow;
response = services.Browse(requestHeader, null,
requestedMaxReferencesPerNode, browseCollection,
out browseResultCollection, out diagnosticsInfoCollection);
ServerFixtureUtils.ValidateResponse(response);
ServerFixtureUtils.ValidateDiagnosticInfos(diagnosticsInfoCollection, browseCollection);
allResults.AddRange(browseResultCollection);
}
catch (ServiceResultException sre)
{
if (sre.StatusCode == StatusCodes.BadEncodingLimitsExceeded ||
sre.StatusCode == StatusCodes.BadResponseTooLarge)
{
// try to address by overriding operation limit
maxNodesPerBrowse = maxNodesPerBrowse == 0 ?
(uint)browseCollection.Count / 2 : maxNodesPerBrowse / 2;
repeatBrowse = true;
}
else
{
throw;
}
}
} while (repeatBrowse);
if (maxNodesPerBrowse == 0)
{
browseDescriptionCollection.Clear();
}
else
{
browseDescriptionCollection = browseDescriptionCollection.Skip((int)maxNodesPerBrowse).ToArray();
}
// Browse next
var continuationPoints = ServerFixtureUtils.PrepareBrowseNext(browseResultCollection);
while (continuationPoints.Any())
{
requestHeader.Timestamp = DateTime.UtcNow;
response = services.BrowseNext(requestHeader, false, continuationPoints,
out var browseNextResultCollection, out diagnosticsInfoCollection);
ServerFixtureUtils.ValidateResponse(response);
ServerFixtureUtils.ValidateDiagnosticInfos(diagnosticsInfoCollection, 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, null));
}
}
browseDescriptionCollection = ServerFixtureUtils.CreateBrowseDescriptionCollectionFromNodeId(browseTable, browseTemplate);
}
referenceDescriptions.Sort((x, y) => (x.NodeId.CompareTo(y.NodeId)));
TestContext.Out.WriteLine("Found {0} references on server.", referenceDescriptions.Count);
foreach (var reference in referenceDescriptions)
{
TestContext.Out.WriteLine("NodeId {0} {1} {2}", reference.NodeId, reference.NodeClass, reference.BrowseName);
}
return(referenceDescriptions);
}
public void GetOperationLimits()
{
var readIdCollection = new ReadValueIdCollection()
{
new ReadValueId()
{
AttributeId = Attributes.Value, NodeId = VariableIds.Server_ServerCapabilities_OperationLimits_MaxNodesPerRead
},
new ReadValueId()
{
AttributeId = Attributes.Value, NodeId = VariableIds.Server_ServerCapabilities_OperationLimits_MaxNodesPerHistoryReadData
},
new ReadValueId()
{
AttributeId = Attributes.Value, NodeId = VariableIds.Server_ServerCapabilities_OperationLimits_MaxNodesPerHistoryReadEvents
},
new ReadValueId()
{
AttributeId = Attributes.Value, NodeId = VariableIds.Server_ServerCapabilities_OperationLimits_MaxNodesPerWrite
},
new ReadValueId()
{
AttributeId = Attributes.Value, NodeId = VariableIds.Server_ServerCapabilities_OperationLimits_MaxNodesPerHistoryUpdateData
},
new ReadValueId()
{
AttributeId = Attributes.Value, NodeId = VariableIds.Server_ServerCapabilities_OperationLimits_MaxNodesPerHistoryUpdateEvents
},
new ReadValueId()
{
AttributeId = Attributes.Value, NodeId = VariableIds.Server_ServerCapabilities_OperationLimits_MaxNodesPerBrowse
},
new ReadValueId()
{
AttributeId = Attributes.Value, NodeId = VariableIds.Server_ServerCapabilities_OperationLimits_MaxMonitoredItemsPerCall
},
new ReadValueId()
{
AttributeId = Attributes.Value, NodeId = VariableIds.Server_ServerCapabilities_OperationLimits_MaxNodesPerNodeManagement
},
new ReadValueId()
{
AttributeId = Attributes.Value, NodeId = VariableIds.Server_ServerCapabilities_OperationLimits_MaxNodesPerRegisterNodes
},
new ReadValueId()
{
AttributeId = Attributes.Value, NodeId = VariableIds.Server_ServerCapabilities_OperationLimits_MaxNodesPerTranslateBrowsePathsToNodeIds
},
new ReadValueId()
{
AttributeId = Attributes.Value, NodeId = VariableIds.Server_ServerCapabilities_OperationLimits_MaxNodesPerMethodCall
}
};
var requestHeader = m_requestHeader;
requestHeader.Timestamp = DateTime.UtcNow;
var response = m_server.Read(requestHeader, MaxAge, TimestampsToReturn.Neither, readIdCollection, out var results, out var diagnosticInfos);
ServerFixtureUtils.ValidateResponse(response);
ServerFixtureUtils.ValidateDiagnosticInfos(diagnosticInfos, results);
Assert.NotNull(results);
Assert.AreEqual(readIdCollection.Count, results.Count);
m_operationLimits = new OperationLimits()
{
MaxNodesPerRead = (uint)results[0].Value,
MaxNodesPerHistoryReadData = (uint)results[1].Value,
MaxNodesPerHistoryReadEvents = (uint)results[2].Value,
MaxNodesPerWrite = (uint)results[3].Value,
MaxNodesPerHistoryUpdateData = (uint)results[4].Value,
MaxNodesPerHistoryUpdateEvents = (uint)results[5].Value,
MaxNodesPerBrowse = (uint)results[6].Value,
MaxMonitoredItemsPerCall = (uint)results[7].Value,
MaxNodesPerNodeManagement = (uint)results[8].Value,
MaxNodesPerRegisterNodes = (uint)results[9].Value,
MaxNodesPerTranslateBrowsePathsToNodeIds = (uint)results[10].Value,
MaxNodesPerMethodCall = (uint)results[11].Value
};
}
