public static async Task <GlobalDiscoveryTestServer> StartGDS(bool clean)
{
GlobalDiscoveryTestServer server = null;
int testPort = ServerFixtureUtils.GetNextFreeIPPort();
bool retryStartServer = false;
int serverStartRetries = 25;
do
{
try
{
server = new GlobalDiscoveryTestServer(true);
await server.StartServer(clean, testPort).ConfigureAwait(false);
}
catch (ServiceResultException sre)
{
serverStartRetries--;
testPort = s_random.Next(ServerFixtureUtils.MinTestPort, ServerFixtureUtils.MaxTestPort);
if (serverStartRetries == 0 ||
sre.StatusCode != StatusCodes.BadNoCommunication)
{
throw;
}
retryStartServer = true;
}
await Task.Delay(s_random.Next(100, 1000)).ConfigureAwait(false);
} while (retryStartServer);
return(server);
}
/// <summary>
/// Start a host for reverse connections on random port.
/// </summary>
public async Task StartReverseConnectHost()
{
Random m_random = new Random();
int testPort = ServerFixtureUtils.GetNextFreeIPPort();
bool retryStartServer = false;
int serverStartRetries = 25;
do
{
try
{
var reverseConnectUri = new Uri("opc.tcp://localhost:" + testPort);
ReverseConnectManager.AddEndpoint(reverseConnectUri);
ReverseConnectManager.StartService(Config);
ReverseConnectUri = reverseConnectUri.ToString();
}
catch (ServiceResultException sre)
{
serverStartRetries--;
if (serverStartRetries == 0 ||
sre.StatusCode != StatusCodes.BadNoCommunication)
{
throw;
}
testPort = m_random.Next(ServerFixtureUtils.MinTestPort, ServerFixtureUtils.MaxTestPort);
retryStartServer = true;
}
await Task.Delay(m_random.Next(100, 1000)).ConfigureAwait(false);
} while (retryStartServer);
}
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);
}
}
