/// <summary>
/// Displays the dialog.
/// </summary>
public void Show(Session session, ReadValueIdCollection valueIds)
{
if (session == null) throw new ArgumentNullException("session");
m_session = session;
BrowseCTRL.SetView(m_session, BrowseViewType.Objects, null);
ReadValuesCTRL.Initialize(session, valueIds);
MoveBTN_Click(BackBTN, null);
Show();
BringToFront();
}
/// <summary>
/// Sets the nodes in the control.
/// </summary>
public void Initialize(Session session, ReadValueIdCollection valueIds)
{
if (session == null) throw new ArgumentNullException("session");
Clear();
m_session = session;
foreach (ReadValueId valueId in valueIds)
{
AddItem(valueId);
}
AdjustColumns();
}
/// <summary>
/// Prompts the user to enter a value to write.
/// </summary>
/// <param name="session">The session to use.</param>
/// <param name="nodeId">The identifier for the node to write to.</param>
/// <param name="attributeId">The attribute being written.</param>
/// <returns>True if successful. False if the operation was cancelled.</returns>
public bool ShowDialog(Session session, NodeId nodeId, uint attributeId)
{
m_session = session;
m_nodeId = nodeId;
m_attributeId = attributeId;
ReadValueId nodeToRead = new ReadValueId();
nodeToRead.NodeId = nodeId;
nodeToRead.AttributeId = attributeId;
ReadValueIdCollection nodesToRead = new ReadValueIdCollection();
nodesToRead.Add(nodeToRead);
// read current value.
DataValueCollection results = null;
DiagnosticInfoCollection diagnosticInfos = null;
m_session.Read(
null,
0,
TimestampsToReturn.Neither,
nodesToRead,
out results,
out diagnosticInfos);
ClientBase.ValidateResponse(results, nodesToRead);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToRead);
m_value = results[0];
ValueTB.Text = Utils.Format("{0}", m_value.WrappedValue);
// display the dialog.
if (ShowDialog() != DialogResult.OK)
{
return false;
}
return true;
}
/// <summary>
/// Adds the properties to the control.
/// </summary>
private void AddProperties()
{
// build list of properties to read.
ReadValueIdCollection nodesToRead = new ReadValueIdCollection();
Browser browser = new Browser(m_session);
browser.BrowseDirection = BrowseDirection.Forward;
browser.ReferenceTypeId = ReferenceTypeIds.HasProperty;
browser.IncludeSubtypes = true;
browser.NodeClassMask = (int)NodeClass.Variable;
browser.ContinueUntilDone = true;
ReferenceDescriptionCollection references = browser.Browse(m_nodeId);
foreach (ReferenceDescription reference in references)
{
ReadValueId valueId = new ReadValueId();
valueId.NodeId = (NodeId)reference.NodeId;
valueId.AttributeId = Attributes.Value;
valueId.IndexRange = null;
valueId.DataEncoding = null;
nodesToRead.Add(valueId);
}
// check for empty list.
if (nodesToRead.Count == 0)
{
return;
}
// read values.
DataValueCollection values;
DiagnosticInfoCollection diagnosticInfos;
m_session.Read(
null,
0,
TimestampsToReturn.Neither,
nodesToRead,
out values,
out diagnosticInfos);
ClientBase.ValidateResponse(values, nodesToRead);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToRead);
// update control.
for (int ii = 0; ii < nodesToRead.Count; ii++)
{
NodeField field = new NodeField();
field.ValueId = nodesToRead[ii];
field.Name = references[ii].ToString();
field.Value = values[ii].Value;
field.StatusCode = values[ii].StatusCode;
if (diagnosticInfos != null && diagnosticInfos.Count > ii)
{
field.DiagnosticInfo = diagnosticInfos[ii];
}
AddItem(field, "Property", -1);
}
}
/// <see cref="BaseListCtrl.GetDataToDrag" />
protected override object GetDataToDrag()
{
ReadValueIdCollection valueIds = new ReadValueIdCollection();
foreach (ListViewItem listItem in ItemsLV.SelectedItems)
{
NodeField field = listItem.Tag as NodeField;
if (field != null && field.ValueId != null)
{
valueIds.Add(field.ValueId);
}
}
return valueIds;
}
/// <summary>
/// Returns the items in the control.
/// </summary>
public ReadValueIdCollection GetValueIds()
{
ReadValueIdCollection valueIds = new ReadValueIdCollection();
foreach (ListViewItem item in ItemsLV.Items)
{
ReadValueId valueId = item.Tag as ReadValueId;
if (valueId != null)
{
valueIds.Add(valueId);
}
}
return valueIds;
}
/// <summary>
/// Reads the attributes for the node.
/// </summary>
public void ReadAttributes(NodeId nodeId, bool showProperties)
{
AttributesLV.Items.Clear();
if (NodeId.IsNull(nodeId))
{
return;
}
// build list of attributes to read.
ReadValueIdCollection nodesToRead = new ReadValueIdCollection();
foreach (uint attributeId in Attributes.GetIdentifiers())
{
ReadValueId nodeToRead = new ReadValueId();
nodeToRead.NodeId = nodeId;
nodeToRead.AttributeId = attributeId;
nodesToRead.Add(nodeToRead);
}
// read the attributes.
DataValueCollection results = null;
DiagnosticInfoCollection diagnosticInfos = null;
m_session.Read(
null,
0,
TimestampsToReturn.Neither,
nodesToRead,
out results,
out diagnosticInfos);
ClientBase.ValidateResponse(results, nodesToRead);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToRead);
// add the results to the display.
for (int ii = 0; ii < results.Count; ii++)
{
// check for error.
if (StatusCode.IsBad(results[ii].StatusCode))
{
if (results[ii].StatusCode == StatusCodes.BadAttributeIdInvalid)
{
continue;
}
}
// add the metadata for the attribute.
uint attributeId = nodesToRead[ii].AttributeId;
ListViewItem item = new ListViewItem(Attributes.GetBrowseName(attributeId));
item.SubItems.Add(Attributes.GetBuiltInType(attributeId).ToString());
if (Attributes.GetValueRank(attributeId) >= 0)
{
item.SubItems[0].Text += "[]";
}
// add the value.
if (StatusCode.IsBad(results[ii].StatusCode))
{
item.SubItems.Add(results[ii].StatusCode.ToString());
}
else
{
item.SubItems.Add(ClientUtils.GetAttributeDisplayText(m_session, attributeId, results[ii].WrappedValue));
}
item.Tag = new AttributeInfo() { NodeToRead = nodesToRead[ii], Value = results[ii] };
item.ImageIndex = ClientUtils.GetImageIndex(nodesToRead[ii].AttributeId, results[ii].Value);
// display in list.
AttributesLV.Items.Add(item);
}
if (showProperties)
{
ReadProperties(nodeId);
}
// set the column widths.
for (int ii = 0; ii < AttributesLV.Columns.Count; ii++)
{
AttributesLV.Columns[ii].Width = -2;
}
}
/// <summary>
/// Finds the targets for the specified reference.
/// </summary>
private static void UpdateInstanceDescriptions(Session session, List<InstanceDeclaration> instances, bool throwOnError)
{
try
{
ReadValueIdCollection nodesToRead = new ReadValueIdCollection();
for (int ii = 0; ii < instances.Count; ii++)
{
ReadValueId nodeToRead = new ReadValueId();
nodeToRead.NodeId = instances[ii].NodeId;
nodeToRead.AttributeId = Attributes.Description;
nodesToRead.Add(nodeToRead);
nodeToRead = new ReadValueId();
nodeToRead.NodeId = instances[ii].NodeId;
nodeToRead.AttributeId = Attributes.DataType;
nodesToRead.Add(nodeToRead);
nodeToRead = new ReadValueId();
nodeToRead.NodeId = instances[ii].NodeId;
nodeToRead.AttributeId = Attributes.ValueRank;
nodesToRead.Add(nodeToRead);
}
// start the browse operation.
DataValueCollection results = null;
DiagnosticInfoCollection diagnosticInfos = null;
session.Read(
null,
0,
TimestampsToReturn.Neither,
nodesToRead,
out results,
out diagnosticInfos);
ClientBase.ValidateResponse(results, nodesToRead);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToRead);
// update the instances.
for (int ii = 0; ii < nodesToRead.Count; ii += 3)
{
InstanceDeclaration instance = instances[ii / 3];
instance.Description = results[ii].GetValue<LocalizedText>(LocalizedText.Null).Text;
instance.DataType = results[ii + 1].GetValue<NodeId>(NodeId.Null);
instance.ValueRank = results[ii + 2].GetValue<int>(ValueRanks.Any);
if (!NodeId.IsNull(instance.DataType))
{
instance.BuiltInType = DataTypes.GetBuiltInType(instance.DataType, session.TypeTree);
instance.DataTypeDisplayText = session.NodeCache.GetDisplayText(instance.DataType);
if (instance.ValueRank >= 0)
{
instance.DataTypeDisplayText += "[]";
}
}
}
}
catch (Exception exception)
{
if (throwOnError)
{
throw new ServiceResultException(exception, StatusCodes.BadUnexpectedError);
}
}
}
/// <summary>
/// Updates the values from the server.
/// </summary>
private void UpdateValues()
{
ReadValueIdCollection valuesToRead = new ReadValueIdCollection();
foreach (ListViewItem item in ItemsLV.Items)
{
ItemInfo info = item.Tag as ItemInfo;
if (info == null)
{
continue;
}
ReadValueId valueToRead = new ReadValueId();
valueToRead.NodeId = info.NodeId;
valueToRead.AttributeId = info.AttributeId;
valueToRead.Handle = item;
valuesToRead.Add(valueToRead);
}
DataValueCollection results;
DiagnosticInfoCollection diagnosticInfos;
m_session.Read(
null,
0,
TimestampsToReturn.Neither,
valuesToRead,
out results,
out diagnosticInfos);
ClientBase.ValidateResponse(results, valuesToRead);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, valuesToRead);
for (int ii = 0; ii < valuesToRead.Count; ii++)
{
ListViewItem item = (ListViewItem)valuesToRead[ii].Handle;
ItemInfo info = (ItemInfo)item.Tag;
info.Value = results[ii];
UpdateItem(item, info);
}
AdjustColumns();
}
/// <summary>
/// Reads the display name for a set of Nodes.
/// </summary>
public void ReadDisplayName(
IList<NodeId> nodeIds,
out List<string> displayNames,
out List<ServiceResult> errors)
{
displayNames = new List<string>();
errors = new List<ServiceResult>();
// build list of values to read.
ReadValueIdCollection valuesToRead = new ReadValueIdCollection();
for (int ii = 0; ii < nodeIds.Count; ii++)
{
ReadValueId valueToRead = new ReadValueId();
valueToRead.NodeId = nodeIds[ii];
valueToRead.AttributeId = Attributes.DisplayName;
valueToRead.IndexRange = null;
valueToRead.DataEncoding = null;
valuesToRead.Add(valueToRead);
}
// read the values.
DataValueCollection results = null;
DiagnosticInfoCollection diagnosticInfos = null;
ResponseHeader responseHeader = Read(
null,
Int32.MaxValue,
TimestampsToReturn.Both,
valuesToRead,
out results,
out diagnosticInfos);
// verify that the server returned the correct number of results.
ClientBase.ValidateResponse(results, valuesToRead);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, valuesToRead);
for (int ii = 0; ii < nodeIds.Count; ii++)
{
displayNames.Add(String.Empty);
errors.Add(ServiceResult.Good);
// process any diagnostics associated with bad or uncertain data.
if (StatusCode.IsNotGood(results[ii].StatusCode))
{
errors[ii] = new ServiceResult(results[ii].StatusCode, ii, diagnosticInfos, responseHeader.StringTable);
continue;
}
// extract the name.
LocalizedText displayName = results[ii].GetValue<LocalizedText>(null);
if (!LocalizedText.IsNullOrEmpty(displayName))
{
displayNames[ii] = displayName.Text;
}
}
}
/// <summary>
/// Invokes the Read service.
/// </summary>
/// <param name="requestHeader">The request header.</param>
/// <param name="maxAge">The Maximum age of the value to be read in milliseconds.</param>
/// <param name="timestampsToReturn">The type of timestamps to be returned for the requested Variables.</param>
/// <param name="nodesToRead">The list of Nodes and their Attributes to read.</param>
/// <param name="results">The list of returned Attribute values</param>
/// <param name="diagnosticInfos">The diagnostic information for the results.</param>
/// <returns>
/// Returns a <see cref="ResponseHeader"/> object
/// </returns>
public override ResponseHeader Read(
RequestHeader requestHeader,
double maxAge,
TimestampsToReturn timestampsToReturn,
ReadValueIdCollection nodesToRead,
out DataValueCollection results,
out DiagnosticInfoCollection diagnosticInfos)
{
OperationContext context = ValidateRequest(requestHeader, RequestType.Read);
try
{
if (nodesToRead == null || nodesToRead.Count == 0)
{
throw new ServiceResultException(StatusCodes.BadNothingToDo);
}
m_serverInternal.NodeManager.Read(
context,
maxAge,
timestampsToReturn,
nodesToRead,
out results,
out diagnosticInfos);
return CreateResponse(requestHeader, context.StringTable);
}
catch (ServiceResultException e)
{
lock (ServerInternal.DiagnosticsLock)
{
ServerInternal.ServerDiagnostics.RejectedRequestsCount++;
if (IsSecurityError(e.StatusCode))
{
ServerInternal.ServerDiagnostics.SecurityRejectedRequestsCount++;
}
}
throw TranslateException(context, e);
}
finally
{
OnRequestComplete(context);
}
}
/// <summary>
/// Reads the value for a node.
/// </summary>
/// <param name="nodeId">The node Id.</param>
/// <returns></returns>
public DataValue ReadValue(NodeId nodeId)
{
ReadValueId itemToRead = new ReadValueId();
itemToRead.NodeId = nodeId;
itemToRead.AttributeId = Attributes.Value;
ReadValueIdCollection itemsToRead = new ReadValueIdCollection();
itemsToRead.Add(itemToRead);
// read from server.
DataValueCollection values = null;
DiagnosticInfoCollection diagnosticInfos = null;
ResponseHeader responseHeader = Read(
null,
0,
TimestampsToReturn.Both,
itemsToRead,
out values,
out diagnosticInfos);
ClientBase.ValidateResponse(values, itemsToRead);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, itemsToRead);
if (StatusCode.IsBad(values[0].StatusCode))
{
ServiceResult result = ClientBase.GetResult(values[0].StatusCode, 0, diagnosticInfos, responseHeader);
throw new ServiceResultException(result);
}
return values[0];
}
/// <summary>
/// Reads the values for a set of variables.
/// </summary>
/// <param name="variableIds">The variable ids.</param>
/// <param name="expectedTypes">The expected types.</param>
/// <param name="values">The list of returned values.</param>
/// <param name="errors">The list of returned errors.</param>
public void ReadValues(
IList<NodeId> variableIds,
IList<Type> expectedTypes,
out List<object> values,
out List<ServiceResult> errors)
{
values = new List<object>();
errors = new List<ServiceResult>();
// build list of values to read.
ReadValueIdCollection valuesToRead = new ReadValueIdCollection();
for (int ii = 0; ii < variableIds.Count; ii++)
{
ReadValueId valueToRead = new ReadValueId();
valueToRead.NodeId = variableIds[ii];
valueToRead.AttributeId = Attributes.Value;
valueToRead.IndexRange = null;
valueToRead.DataEncoding = null;
valuesToRead.Add(valueToRead);
}
// read the values.
DataValueCollection results = null;
DiagnosticInfoCollection diagnosticInfos = null;
ResponseHeader responseHeader = Read(
null,
Int32.MaxValue,
TimestampsToReturn.Both,
valuesToRead,
out results,
out diagnosticInfos);
// verify that the server returned the correct number of results.
ClientBase.ValidateResponse(results, valuesToRead);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, valuesToRead);
for (int ii = 0; ii < variableIds.Count; ii++)
{
values.Add(null);
errors.Add(ServiceResult.Good);
// process any diagnostics associated with bad or uncertain data.
if (StatusCode.IsNotGood(results[ii].StatusCode))
{
errors[ii] = new ServiceResult(results[ii].StatusCode, ii, diagnosticInfos, responseHeader.StringTable);
continue;
}
object value = results[ii].Value;
// extract the body from extension objects.
ExtensionObject extension = value as ExtensionObject;
if (extension != null && extension.Body is IEncodeable)
{
value = extension.Body;
}
// check expected type.
if (expectedTypes[ii] != null && !expectedTypes[ii].IsInstanceOfType(value))
{
errors[ii] = ServiceResult.Create(
StatusCodes.BadTypeMismatch,
"Value {0} does not have expected type: {1}.",
value,
expectedTypes[ii].Name);
continue;
}
// suitable value found.
values[ii] = value;
}
}
public Node ReadNode(NodeId nodeId)
{
// build list of attributes.
SortedDictionary<uint,DataValue> attributes = new SortedDictionary<uint,DataValue>();
attributes.Add(Attributes.NodeId, null);
attributes.Add(Attributes.NodeClass, null);
attributes.Add(Attributes.BrowseName, null);
attributes.Add(Attributes.DisplayName, null);
attributes.Add(Attributes.Description, null);
attributes.Add(Attributes.WriteMask, null);
attributes.Add(Attributes.UserWriteMask, null);
attributes.Add(Attributes.DataType, null);
attributes.Add(Attributes.ValueRank, null);
attributes.Add(Attributes.ArrayDimensions, null);
attributes.Add(Attributes.AccessLevel, null);
attributes.Add(Attributes.UserAccessLevel, null);
attributes.Add(Attributes.Historizing, null);
attributes.Add(Attributes.MinimumSamplingInterval, null);
attributes.Add(Attributes.EventNotifier, null);
attributes.Add(Attributes.Executable, null);
attributes.Add(Attributes.UserExecutable, null);
attributes.Add(Attributes.IsAbstract, null);
attributes.Add(Attributes.InverseName, null);
attributes.Add(Attributes.Symmetric, null);
attributes.Add(Attributes.ContainsNoLoops, null);
// build list of values to read.
ReadValueIdCollection itemsToRead = new ReadValueIdCollection();
foreach (uint attributeId in attributes.Keys)
{
ReadValueId itemToRead = new ReadValueId();
itemToRead.NodeId = nodeId;
itemToRead.AttributeId = attributeId;
itemsToRead.Add(itemToRead);
}
// read from server.
DataValueCollection values = null;
DiagnosticInfoCollection diagnosticInfos = null;
ResponseHeader responseHeader = Read(
null,
0,
TimestampsToReturn.Neither,
itemsToRead,
out values,
out diagnosticInfos);
ClientBase.ValidateResponse(values, itemsToRead);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, itemsToRead);
// process results.
int? nodeClass = null;
for (int ii = 0; ii < itemsToRead.Count; ii++)
{
uint attributeId = itemsToRead[ii].AttributeId;
// the node probably does not exist if the node class is not found.
if (attributeId == Attributes.NodeClass)
{
if (!DataValue.IsGood(values[ii]))
{
throw ServiceResultException.Create(values[ii].StatusCode, ii, diagnosticInfos, responseHeader.StringTable);
}
// check for valid node class.
nodeClass = values[ii].Value as int?;
if (nodeClass == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "Node does not have a valid value for NodeClass: {0}.", values[ii].Value);
}
}
else
{
if (!DataValue.IsGood(values[ii]))
{
// check for unsupported attributes.
if (values[ii].StatusCode == StatusCodes.BadAttributeIdInvalid)
{
continue;
}
// all supported attributes must be readable.
if (attributeId != Attributes.Value)
{
throw ServiceResultException.Create(values[ii].StatusCode, ii, diagnosticInfos, responseHeader.StringTable);
}
}
}
attributes[attributeId] = values[ii];
}
Node node = null;
DataValue value = null;
switch ((NodeClass)nodeClass.Value)
{
default:
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "Node does not have a valid value for NodeClass: {0}.", nodeClass.Value);
}
case NodeClass.Object:
{
ObjectNode objectNode = new ObjectNode();
value = attributes[Attributes.EventNotifier];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "Object does not support the EventNotifier attribute.");
}
objectNode.EventNotifier = (byte)attributes[Attributes.EventNotifier].GetValue(typeof(byte));
node = objectNode;
break;
}
case NodeClass.ObjectType:
{
ObjectTypeNode objectTypeNode = new ObjectTypeNode();
value = attributes[Attributes.IsAbstract];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "ObjectType does not support the IsAbstract attribute.");
}
objectTypeNode.IsAbstract = (bool)attributes[Attributes.IsAbstract].GetValue(typeof(bool));
node = objectTypeNode;
break;
}
case NodeClass.Variable:
{
VariableNode variableNode = new VariableNode();
// DataType Attribute
value = attributes[Attributes.DataType];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "Variable does not support the DataType attribute.");
}
variableNode.DataType = (NodeId)attributes[Attributes.DataType].GetValue(typeof(NodeId));
// ValueRank Attribute
value = attributes[Attributes.ValueRank];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "Variable does not support the ValueRank attribute.");
}
variableNode.ValueRank = (int)attributes[Attributes.ValueRank].GetValue(typeof(int));
// ArrayDimensions Attribute
value = attributes[Attributes.ArrayDimensions];
if (value != null)
{
if (value.Value == null)
{
variableNode.ArrayDimensions = new uint[0];
}
else
{
variableNode.ArrayDimensions = (uint[])value.GetValue(typeof(uint[]));
}
}
// AccessLevel Attribute
value = attributes[Attributes.AccessLevel];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "Variable does not support the AccessLevel attribute.");
}
variableNode.AccessLevel = (byte)attributes[Attributes.AccessLevel].GetValue(typeof(byte));
// UserAccessLevel Attribute
value = attributes[Attributes.UserAccessLevel];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "Variable does not support the UserAccessLevel attribute.");
}
variableNode.UserAccessLevel = (byte)attributes[Attributes.UserAccessLevel].GetValue(typeof(byte));
// Historizing Attribute
value = attributes[Attributes.Historizing];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "Variable does not support the Historizing attribute.");
}
variableNode.Historizing = (bool)attributes[Attributes.Historizing].GetValue(typeof(bool));
// MinimumSamplingInterval Attribute
value = attributes[Attributes.MinimumSamplingInterval];
if (value != null)
{
variableNode.MinimumSamplingInterval = Convert.ToDouble(attributes[Attributes.MinimumSamplingInterval].Value);
}
node = variableNode;
break;
}
case NodeClass.VariableType:
{
VariableTypeNode variableTypeNode = new VariableTypeNode();
// IsAbstract Attribute
value = attributes[Attributes.IsAbstract];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "VariableType does not support the IsAbstract attribute.");
}
variableTypeNode.IsAbstract = (bool)attributes[Attributes.IsAbstract].GetValue(typeof(bool));
// DataType Attribute
value = attributes[Attributes.DataType];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "VariableType does not support the DataType attribute.");
}
variableTypeNode.DataType = (NodeId)attributes[Attributes.DataType].GetValue(typeof(NodeId));
// ValueRank Attribute
value = attributes[Attributes.ValueRank];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "VariableType does not support the ValueRank attribute.");
}
variableTypeNode.ValueRank = (int)attributes[Attributes.ValueRank].GetValue(typeof(int));
// ArrayDimensions Attribute
value = attributes[Attributes.ArrayDimensions];
if (value != null && value.Value != null)
{
variableTypeNode.ArrayDimensions = (uint[])attributes[Attributes.ArrayDimensions].GetValue(typeof(uint[]));
}
node = variableTypeNode;
break;
}
case NodeClass.Method:
{
MethodNode methodNode = new MethodNode();
// Executable Attribute
value = attributes[Attributes.Executable];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "Method does not support the Executable attribute.");
}
methodNode.Executable = (bool)attributes[Attributes.Executable].GetValue(typeof(bool));
// UserExecutable Attribute
value = attributes[Attributes.UserExecutable];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "Method does not support the UserExecutable attribute.");
}
methodNode.UserExecutable = (bool)attributes[Attributes.UserExecutable].GetValue(typeof(bool));
node = methodNode;
break;
}
case NodeClass.DataType:
{
DataTypeNode dataTypeNode = new DataTypeNode();
// IsAbstract Attribute
value = attributes[Attributes.IsAbstract];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "DataType does not support the IsAbstract attribute.");
}
dataTypeNode.IsAbstract = (bool)attributes[Attributes.IsAbstract].GetValue(typeof(bool));
node = dataTypeNode;
break;
}
case NodeClass.ReferenceType:
{
ReferenceTypeNode referenceTypeNode = new ReferenceTypeNode();
// IsAbstract Attribute
value = attributes[Attributes.IsAbstract];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "ReferenceType does not support the IsAbstract attribute.");
}
referenceTypeNode.IsAbstract = (bool)attributes[Attributes.IsAbstract].GetValue(typeof(bool));
// Symmetric Attribute
value = attributes[Attributes.Symmetric];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "ReferenceType does not support the Symmetric attribute.");
}
referenceTypeNode.Symmetric = (bool)attributes[Attributes.IsAbstract].GetValue(typeof(bool));
// InverseName Attribute
value = attributes[Attributes.InverseName];
if (value != null && value.Value != null)
{
referenceTypeNode.InverseName = (LocalizedText)attributes[Attributes.InverseName].GetValue(typeof(LocalizedText));
}
node = referenceTypeNode;
break;
}
case NodeClass.View:
{
ViewNode viewNode = new ViewNode();
// EventNotifier Attribute
value = attributes[Attributes.EventNotifier];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "View does not support the EventNotifier attribute.");
}
viewNode.EventNotifier = (byte)attributes[Attributes.EventNotifier].GetValue(typeof(byte));
// ContainsNoLoops Attribute
value = attributes[Attributes.ContainsNoLoops];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "View does not support the ContainsNoLoops attribute.");
}
viewNode.ContainsNoLoops = (bool)attributes[Attributes.ContainsNoLoops].GetValue(typeof(bool));
node = viewNode;
break;
}
}
// NodeId Attribute
value = attributes[Attributes.NodeId];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "Node does not support the NodeId attribute.");
}
node.NodeId = (NodeId)attributes[Attributes.NodeId].GetValue(typeof(NodeId));
node.NodeClass = (NodeClass)nodeClass.Value;
// BrowseName Attribute
value = attributes[Attributes.BrowseName];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "Node does not support the BrowseName attribute.");
}
node.BrowseName = (QualifiedName)attributes[Attributes.BrowseName].GetValue(typeof(QualifiedName));
// DisplayName Attribute
value = attributes[Attributes.DisplayName];
if (value == null)
{
throw ServiceResultException.Create(StatusCodes.BadUnexpectedError, "Node does not support the DisplayName attribute.");
}
node.DisplayName = (LocalizedText)attributes[Attributes.DisplayName].GetValue(typeof(LocalizedText));
// Description Attribute
value = attributes[Attributes.Description];
if (value != null && value.Value != null)
{
node.Description = (LocalizedText)attributes[Attributes.Description].GetValue(typeof(LocalizedText));
}
// WriteMask Attribute
value = attributes[Attributes.WriteMask];
if (value != null)
{
node.WriteMask = (uint)attributes[Attributes.WriteMask].GetValue(typeof(uint));
}
// UserWriteMask Attribute
value = attributes[Attributes.UserWriteMask];
if (value != null)
{
node.WriteMask = (uint)attributes[Attributes.UserWriteMask].GetValue(typeof(uint));
}
return node;
}
/// <summary>
/// Updates the local copy of the server's namespace uri and server uri tables.
/// </summary>
public void FetchNamespaceTables()
{
ReadValueIdCollection nodesToRead = new ReadValueIdCollection();
// request namespace array.
ReadValueId valueId = new ReadValueId();
valueId.NodeId = Variables.Server_NamespaceArray;
valueId.AttributeId = Attributes.Value;
nodesToRead.Add(valueId);
// request server array.
valueId = new ReadValueId();
valueId.NodeId = Variables.Server_ServerArray;
valueId.AttributeId = Attributes.Value;
nodesToRead.Add(valueId);
// read from server.
DataValueCollection values = null;
DiagnosticInfoCollection diagnosticInfos = null;
ResponseHeader responseHeader = this.Read(
null,
0,
TimestampsToReturn.Both,
nodesToRead,
out values,
out diagnosticInfos);
ValidateResponse(values, nodesToRead);
ValidateDiagnosticInfos(diagnosticInfos, nodesToRead);
// validate namespace array.
ServiceResult result = ValidateDataValue(values[0], typeof(string[]), 0, diagnosticInfos, responseHeader);
if (ServiceResult.IsBad(result))
{
throw new ServiceResultException(result);
}
m_namespaceUris.Update((string[])values[0].Value);
// validate server array.
result = ValidateDataValue(values[1], typeof(string[]), 1, diagnosticInfos, responseHeader);
if (ServiceResult.IsBad(result))
{
throw new ServiceResultException(result);
}
m_serverUris.Update((string[])values[1].Value);
}
/// <summary>
/// Reads the properties for the node.
/// </summary>
private void ReadProperties(NodeId nodeId)
{
// build list of references to browse.
BrowseDescriptionCollection nodesToBrowse = new BrowseDescriptionCollection();
BrowseDescription nodeToBrowse = new BrowseDescription();
nodeToBrowse.NodeId = nodeId;
nodeToBrowse.BrowseDirection = BrowseDirection.Forward;
nodeToBrowse.ReferenceTypeId = Opc.Ua.ReferenceTypeIds.HasProperty;
nodeToBrowse.IncludeSubtypes = true;
nodeToBrowse.NodeClassMask = (uint)NodeClass.Variable;
nodeToBrowse.ResultMask = (uint)BrowseResultMask.All;
nodesToBrowse.Add(nodeToBrowse);
// find properties.
ReferenceDescriptionCollection references = ClientUtils.Browse(m_session, View, nodesToBrowse, false);
// build list of properties to read.
ReadValueIdCollection nodesToRead = new ReadValueIdCollection();
for (int ii = 0; references != null && ii < references.Count; ii++)
{
ReferenceDescription reference = references[ii];
// ignore out of server references.
if (reference.NodeId.IsAbsolute)
{
continue;
}
ReadValueId nodeToRead = new ReadValueId();
nodeToRead.NodeId = (NodeId)reference.NodeId;
nodeToRead.AttributeId = Attributes.Value;
nodeToRead.Handle = reference;
nodesToRead.Add(nodeToRead);
}
if (nodesToRead.Count == 0)
{
return;
}
// read the properties.
DataValueCollection results = null;
DiagnosticInfoCollection diagnosticInfos = null;
m_session.Read(
null,
0,
TimestampsToReturn.Neither,
nodesToRead,
out results,
out diagnosticInfos);
ClientBase.ValidateResponse(results, nodesToRead);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToRead);
// add the results to the display.
for (int ii = 0; ii < results.Count; ii++)
{
ReferenceDescription reference = (ReferenceDescription)nodesToRead[ii].Handle;
TypeInfo typeInfo = TypeInfo.Construct(results[ii].Value);
// add the metadata for the attribute.
ListViewItem item = new ListViewItem(reference.ToString());
item.SubItems.Add(typeInfo.BuiltInType.ToString());
if (typeInfo.ValueRank >= 0)
{
item.SubItems[1].Text += "[]";
}
// add the value.
if (StatusCode.IsBad(results[ii].StatusCode))
{
item.SubItems.Add(results[ii].StatusCode.ToString());
}
else
{
item.SubItems.Add(results[ii].WrappedValue.ToString());
}
item.Tag = new AttributeInfo() { NodeToRead = nodesToRead[ii], Value = results[ii] };
item.ImageIndex = ClientUtils.GetImageIndex(m_session, NodeClass.Variable, Opc.Ua.VariableTypeIds.PropertyType, false);
// display in list.
AttributesLV.Items.Add(item);
}
}
/// <summary>
/// Reads the log file path.
/// </summary>
private void ReadLogFilePath()
{
if (m_session == null)
{
return;
}
try
{
// want to get error text for this call.
m_session.ReturnDiagnostics = DiagnosticsMasks.All;
ReadValueId value = new ReadValueId();
value.NodeId = m_logFileNodeId;
value.AttributeId = Attributes.Value;
ReadValueIdCollection valuesToRead = new ReadValueIdCollection();
valuesToRead.Add(value);
DataValueCollection results = null;
DiagnosticInfoCollection diagnosticInfos = null;
ResponseHeader responseHeader = m_session.Read(
null,
0,
TimestampsToReturn.Neither,
valuesToRead,
out results,
out diagnosticInfos);
ClientBase.ValidateResponse(results, valuesToRead);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, valuesToRead);
if (StatusCode.IsBad(results[0].StatusCode))
{
throw ServiceResultException.Create(results[0].StatusCode, 0, diagnosticInfos, responseHeader.StringTable);
}
LogFilePathTB.Text = results[0].GetValue<string>("");
}
catch (Exception exception)
{
ClientUtils.HandleException(this.Text, exception);
}
finally
{
m_session.ReturnDiagnostics = DiagnosticsMasks.None;
}
}
/// <summary>
/// Starts a timer to check that the connection to the server is still available.
/// </summary>
private void StartKeepAliveTimer()
{
int keepAliveInterval = m_keepAliveInterval;
lock (m_eventLock)
{
m_serverState = ServerState.Unknown;
m_lastKeepAliveTime = DateTime.UtcNow;
}
ReadValueIdCollection nodesToRead = new ReadValueIdCollection();
// read the server state.
ReadValueId serverState = new ReadValueId();
serverState.NodeId = Variables.Server_ServerStatus_State;
serverState.AttributeId = Attributes.Value;
serverState.DataEncoding = null;
serverState.IndexRange = null;
nodesToRead.Add(serverState);
// restart the publish timer.
lock (SyncRoot)
{
if (m_keepAliveTimer != null)
{
m_keepAliveTimer.Dispose();
m_keepAliveTimer = null;
}
// start timer.
m_keepAliveTimer = new Timer(OnKeepAlive, nodesToRead, keepAliveInterval, keepAliveInterval);
}
// send initial keep alive.
OnKeepAlive(nodesToRead);
}
private void RefreshBTN_Click(object sender, EventArgs e)
{
try
{
ReadValueId nodeToRead = new ReadValueId();
nodeToRead.NodeId = m_variableId;
nodeToRead.AttributeId = Attributes.Value;
nodeToRead.DataEncoding = m_encodingName;
ReadValueIdCollection nodesToRead = new ReadValueIdCollection();
nodesToRead.Add(nodeToRead);
// read the attributes.
DataValueCollection results = null;
DiagnosticInfoCollection diagnosticInfos = null;
m_session.Read(
null,
0,
TimestampsToReturn.Neither,
nodesToRead,
out results,
out diagnosticInfos);
ClientBase.ValidateResponse(results, nodesToRead);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToRead);
// check for error.
if (StatusCode.IsBad(results[0].StatusCode))
{
ValueTB.Text = results[0].StatusCode.ToString();
ValueTB.ForeColor = Color.Red;
ValueTB.Font = new Font(ValueTB.Font, FontStyle.Bold);
return;
}
SetValue(results[0].WrappedValue);
}
catch (Exception exception)
{
ClientUtils.HandleException(this.Text, exception);
}
}
/// <summary>
/// Reads the arguments for the method.
/// </summary>
private void ReadArguments(NodeId nodeId)
{
m_inputArguments = null;
m_outputArguments = null;
// build list of references to browse.
BrowseDescriptionCollection nodesToBrowse = new BrowseDescriptionCollection();
BrowseDescription nodeToBrowse = new BrowseDescription();
nodeToBrowse.NodeId = nodeId;
nodeToBrowse.BrowseDirection = BrowseDirection.Forward;
nodeToBrowse.ReferenceTypeId = Opc.Ua.ReferenceTypeIds.HasProperty;
nodeToBrowse.IncludeSubtypes = true;
nodeToBrowse.NodeClassMask = (uint)NodeClass.Variable;
nodeToBrowse.ResultMask = (uint)BrowseResultMask.BrowseName;
nodesToBrowse.Add(nodeToBrowse);
// find properties.
ReferenceDescriptionCollection references = ClientUtils.Browse(m_session, null, nodesToBrowse, false);
// build list of properties to read.
ReadValueIdCollection nodesToRead = new ReadValueIdCollection();
for (int ii = 0; references != null && ii < references.Count; ii++)
{
ReferenceDescription reference = references[ii];
// ignore out of server references.
if (reference.NodeId.IsAbsolute)
{
continue;
}
// ignore other properties.
if (reference.BrowseName != Opc.Ua.BrowseNames.InputArguments && reference.BrowseName != Opc.Ua.BrowseNames.OutputArguments)
{
continue;
}
ReadValueId nodeToRead = new ReadValueId();
nodeToRead.NodeId = (NodeId)reference.NodeId;
nodeToRead.AttributeId = Attributes.Value;
nodeToRead.Handle = reference;
nodesToRead.Add(nodeToRead);
}
// method has no arguments.
if (nodesToRead.Count == 0)
{
return;
}
// read the arguments.
DataValueCollection results = null;
DiagnosticInfoCollection diagnosticInfos = null;
m_session.Read(
null,
0,
TimestampsToReturn.Neither,
nodesToRead,
out results,
out diagnosticInfos);
ClientBase.ValidateResponse(results, nodesToRead);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToRead);
// save the results.
for (int ii = 0; ii < results.Count; ii++)
{
ReferenceDescription reference = (ReferenceDescription)nodesToRead[ii].Handle;
if (StatusCode.IsGood(results[ii].StatusCode))
{
if (reference.BrowseName == Opc.Ua.BrowseNames.InputArguments)
{
m_inputArguments = (Argument[])ExtensionObject.ToArray(results[ii].GetValue<ExtensionObject[]>(null), typeof(Argument));
}
if (reference.BrowseName == Opc.Ua.BrowseNames.OutputArguments)
{
m_outputArguments = (Argument[])ExtensionObject.ToArray(results[ii].GetValue<ExtensionObject[]>(null), typeof(Argument));
}
}
}
// set default values for input arguments.
if (m_inputArguments != null)
{
foreach (Argument argument in m_inputArguments)
{
argument.Value = TypeInfo.GetDefaultValue(argument.DataType, argument.ValueRank, m_session.TypeTree);
}
}
}
/// <summary>
/// Reads the values for a set of variables.
/// </summary>
static void Read(Session session)
{
IList<NodeOfInterest> results = GetNodeIds(session, Opc.Ua.Objects.ObjectsFolder,
VariableBrowsePaths.ToArray());
// build list of nodes to read.
ReadValueIdCollection nodesToRead = new ReadValueIdCollection();
for (int ii = 0; ii < results.Count; ii++)
{
ReadValueId nodeToRead = new ReadValueId();
nodeToRead.NodeId = results[ii].NodeId;
nodeToRead.AttributeId = Attributes.Value;
nodesToRead.Add(nodeToRead);
}
// read values.
DataValueCollection values;
DiagnosticInfoCollection diagnosticInfos;
ResponseHeader responseHeader = session.Read(
null,
0,
TimestampsToReturn.Both,
nodesToRead,
out values,
out diagnosticInfos);
// verify that the server returned the correct number of results.
Session.ValidateResponse(values, nodesToRead);
Session.ValidateDiagnosticInfos(diagnosticInfos, nodesToRead);
// process results.
for (int ii = 0; ii < values.Count; ii++)
{
// check for error.
if (StatusCode.IsBad(values[ii].StatusCode))
{
ServiceResult result = Session.GetResult(values[ii].StatusCode, ii, diagnosticInfos, responseHeader);
Console.WriteLine("Read result for {0}: {1}", VariableBrowsePaths[ii], result.ToLongString());
continue;
}
// write value.
Console.WriteLine( "{0}: V={1}, Q={2}, SrvT={3}, SrcT={4}",nodesToRead[ii].NodeId, values[ii].Value.ToString(),
values[ii].StatusCode.ToString(), values[ii].ServerTimestamp, values[ii].SourceTimestamp);
}
}
/// <summary>
/// Used by the performance test.
/// </summary>
public override ResponseHeader Read(
RequestHeader requestHeader,
double maxAge,
TimestampsToReturn timestampsToReturn,
ReadValueIdCollection nodesToRead,
out DataValueCollection values,
out DiagnosticInfoCollection diagnosticInfos)
{
if (requestHeader.ReturnDiagnostics != 5000)
{
return base.Read(requestHeader, maxAge, timestampsToReturn, nodesToRead, out values, out diagnosticInfos);
}
diagnosticInfos = null;
DataValue value = new DataValue();
value.WrappedValue = new Variant((int)1);
value.SourceTimestamp = DateTime.UtcNow;
values = new DataValueCollection(nodesToRead.Count);
foreach (ReadValueId valueId in nodesToRead)
{
values.Add(value);
}
return new ResponseHeader();
}
/// <summary>
/// Reads the application description from the GDS.
/// </summary>
private ApplicationDescription Read(NodeId nodeId)
{
NamespaceTable wellKnownNamespaceUris = new NamespaceTable();
wellKnownNamespaceUris.Append(Namespaces.OpcUaGds);
string[] browsePaths = new string[]
{
"1:ApplicationName",
"1:ApplicationType",
"1:ApplicationUri",
"1:ProductUri",
"1:GatewayServerUri",
"1:DiscoveryUrls"
};
List<NodeId> propertyIds = ClientUtils.TranslateBrowsePaths(
ServerCTRL.Session,
nodeId,
wellKnownNamespaceUris,
browsePaths);
ReadValueIdCollection nodesToRead = new ReadValueIdCollection();
foreach (NodeId propertyId in propertyIds)
{
ReadValueId nodeToRead = new ReadValueId();
nodeToRead.NodeId = propertyId;
nodeToRead.AttributeId = Attributes.Value;
nodesToRead.Add(nodeToRead);
}
DataValueCollection results = null;
DiagnosticInfoCollection diagnosticInfos = null;
ServerCTRL.Session.Read(
null,
0,
TimestampsToReturn.Neither,
nodesToRead,
out results,
out diagnosticInfos);
ClientBase.ValidateResponse(results, nodesToRead);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToRead);
ApplicationDescription application = new ApplicationDescription();
application.ApplicationName = results[0].GetValue<LocalizedText>(null);
application.ApplicationType = (ApplicationType)results[1].GetValue<int>((int)ApplicationType.Server);
application.ApplicationUri = results[2].GetValue<string>(null);
application.ProductUri = results[3].GetValue<string>(null);
application.GatewayServerUri = results[4].GetValue<string>(null);
string[] discoveryUrls = results[5].GetValue<string[]>(null);
if (discoveryUrls != null)
{
application.DiscoveryUrls = new StringCollection(discoveryUrls);
}
return application;
}
/// <summary>
/// Reads the contents of a data dictionary.
/// </summary>
private byte[] ReadDictionary(NodeId dictionaryId)
{
// create item to read.
ReadValueId itemToRead = new ReadValueId();
itemToRead.NodeId = dictionaryId;
itemToRead.AttributeId = Attributes.Value;
itemToRead.IndexRange = null;
itemToRead.DataEncoding = null;
ReadValueIdCollection itemsToRead = new ReadValueIdCollection();
itemsToRead.Add(itemToRead);
// read value.
DataValueCollection values;
DiagnosticInfoCollection diagnosticInfos;
ResponseHeader responseHeader = m_session.Read(
null,
0,
TimestampsToReturn.Neither,
itemsToRead,
out values,
out diagnosticInfos);
ClientBase.ValidateResponse(values, itemsToRead);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, itemsToRead);
// check for error.
if (StatusCode.IsBad(values[0].StatusCode))
{
ServiceResult result = ClientBase.GetResult(values[0].StatusCode, 0, diagnosticInfos, responseHeader);
throw new ServiceResultException(result);
}
// return as a byte array.
return values[0].Value as byte[];
}
/// <summary>
/// Invokes the Read service.
/// </summary>
public virtual ResponseHeader Read(
RequestHeader requestHeader,
double maxAge,
TimestampsToReturn timestampsToReturn,
ReadValueIdCollection nodesToRead,
out DataValueCollection results,
out DiagnosticInfoCollection diagnosticInfos)
{
results = null;
diagnosticInfos = null;
ValidateRequest(requestHeader);
// Insert implementation.
return CreateResponse(requestHeader, StatusCodes.BadServiceUnsupported);
}
/// <summary>
/// Runs the test in a background thread.
/// </summary>
private void DoTest(ConfiguredEndpoint endpoint)
{
PerformanceTestResult result = new PerformanceTestResult(endpoint, 100);
result.Results.Add(1, -1);
result.Results.Add(10, -1);
result.Results.Add(50, -1);
result.Results.Add(100, -1);
result.Results.Add(250, -1);
result.Results.Add(500, -1);
try
{
// update the endpoint.
if (endpoint.UpdateBeforeConnect)
{
endpoint.UpdateFromServer();
}
SessionClient client = null;
Uri url = new Uri(endpoint.Description.EndpointUrl);
ITransportChannel channel = SessionChannel.Create(
m_configuration,
endpoint.Description,
endpoint.Configuration,
m_clientCertificate,
m_messageContext);
client = new SessionClient(channel);
List<int> requestSizes = new List<int>(result.Results.Keys);
for (int ii = 0; ii < requestSizes.Count; ii++)
{
// update the progress indicator.
TestProgress((ii * 100) / requestSizes.Count);
lock (m_lock)
{
if (!m_running)
{
break;
}
}
int count = requestSizes[ii];
// initialize request.
RequestHeader requestHeader = new RequestHeader();
requestHeader.ReturnDiagnostics = 5000;
ReadValueIdCollection nodesToRead = new ReadValueIdCollection(count);
for (int jj = 0; jj < count; jj++)
{
ReadValueId item = new ReadValueId();
item.NodeId = new NodeId((uint)jj, 1);
item.AttributeId = Attributes.Value;
nodesToRead.Add(item);
}
// ensure valid connection.
DataValueCollection results = null;
DiagnosticInfoCollection diagnosticInfos = null;
client.Read(
requestHeader,
0,
TimestampsToReturn.Both,
nodesToRead,
out results,
out diagnosticInfos);
if (results.Count != count)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
// do test.
DateTime start = DateTime.UtcNow;
for (int jj = 0; jj < result.Iterations; jj++)
{
client.Read(
requestHeader,
0,
TimestampsToReturn.Both,
nodesToRead,
out results,
out diagnosticInfos);
if (results.Count != count)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
}
DateTime finish = DateTime.UtcNow;
long totalTicks = finish.Ticks - start.Ticks;
decimal averageMilliseconds = ((((decimal)totalTicks) / ((decimal)result.Iterations))) / ((decimal)TimeSpan.TicksPerMillisecond);
result.Results[requestSizes[ii]] = (double)averageMilliseconds;
}
}
finally
{
TestComplete(result);
}
}
/// <summary>
/// Tests the session keep alive when there are no errors.
/// </summary>
private bool DoKeepAliveTest()
{
bool success = true;
double increment = MaxProgress/3;
double position = 0;
m_keepAliveCount = 0;
int currentKeepAlive = Session.KeepAliveInterval;
List<Subscription> subscriptions = new List<Subscription>();
KeepAliveEventHandler handler = new KeepAliveEventHandler(Session_KeepAlive);
try
{
Session.KeepAlive += handler;
// add several subscriptions with long publish intervals.
for (int publishingInterval = 10000; publishingInterval <= 20000; publishingInterval += 1000)
{
Subscription subscription = new Subscription();
subscription.MaxMessageCount = 100;
subscription.LifetimeCount = 100;
subscription.KeepAliveCount = 10;
subscription.PublishingEnabled = true;
subscription.PublishingInterval = publishingInterval;
MonitoredItem monitoredItem = new MonitoredItem();
monitoredItem.StartNodeId = VariableIds.Server_ServerStatus_CurrentTime;
monitoredItem.AttributeId = Attributes.Value;
monitoredItem.SamplingInterval = -1;
monitoredItem.QueueSize = 0;
monitoredItem.DiscardOldest = true;
subscription.AddItem(monitoredItem);
Session.AddSubscription(subscription);
subscription.Create();
subscriptions.Add(subscription);
}
// get a value to read.
ReadValueId nodeToRead = new ReadValueId();
nodeToRead.NodeId = VariableIds.Server_ServerStatus;
nodeToRead.AttributeId = Attributes.Value;
ReadValueIdCollection nodesToRead = new ReadValueIdCollection();
nodesToRead.Add(nodeToRead);
int testDuration = 5000;
// make sure the keep alives come at the expected rate.
for (int keepAliveInterval = 500; keepAliveInterval < 2000; keepAliveInterval += 500)
{
m_keepAliveCount = 0;
DateTime start = DateTime.UtcNow;
DataValueCollection results = null;
DiagnosticInfoCollection diagnosticsInfos = null;
Session.Read(
null,
0,
TimestampsToReturn.Neither,
nodesToRead,
out results,
out diagnosticsInfos);
ClientBase.ValidateResponse(results, nodesToRead);
ClientBase.ValidateDiagnosticInfos(diagnosticsInfos, nodesToRead);
ServerStatusDataType status = ExtensionObject.ToEncodeable(results[0].Value as ExtensionObject) as ServerStatusDataType;
if (status == null)
{
Log("Server did not return a valid ServerStatusDataType structure. Value={0}, Status={1}", results[0].WrappedValue, results[0].StatusCode);
return false;
}
if ((DateTime.UtcNow - start).TotalSeconds > 1)
{
Log("Unexpected delay reading the ServerStatus structure. Delay={0}s", (DateTime.UtcNow - start).TotalSeconds);
return false;
}
Log("Setting keep alive interval to {0}ms.", keepAliveInterval);
Session.KeepAliveInterval = keepAliveInterval;
if (m_errorEvent.WaitOne(testDuration, false))
{
Log("Unexpected error waiting for session keep alives. {0}", m_error.ToLongString());
return false;
}
if (m_keepAliveCount < testDuration / keepAliveInterval)
{
Log("Missing session keep alives. Expected={0}, Actual={1}", testDuration / keepAliveInterval, m_keepAliveCount);
return false;
}
Log("{0} keep alives received in {1}ms.", m_keepAliveCount, testDuration);
position += increment;
ReportProgress(position);
}
ReportProgress(MaxProgress);
}
finally
{
Session.RemoveSubscriptions(subscriptions);
Session.KeepAliveInterval = currentKeepAlive;
Session.KeepAlive -= handler;
}
return success;
}
/// <summary>
/// Handles a read operations that fetch data from an external source.
/// </summary>
protected override void Read(
ServerSystemContext context,
IList<ReadValueId> nodesToRead,
IList<DataValue> values,
IList<ServiceResult> errors,
List<NodeHandle> nodesToValidate,
IDictionary<NodeId, NodeState> cache)
{
ReadValueIdCollection requests = new ReadValueIdCollection();
List<int> indexes = new List<int>();
for (int ii = 0; ii < nodesToValidate.Count; ii++)
{
NodeHandle handle = nodesToValidate[ii];
ReadValueId nodeToRead = nodesToRead[ii];
DataValue value = values[ii];
lock (Lock)
{
// validate node.
NodeState source = ValidateNode(context, handle, cache);
if (source == null)
{
continue;
}
// determine if a local node.
if (PredefinedNodes.ContainsKey(source.NodeId))
{
errors[handle.Index] = source.ReadAttribute(
context,
nodeToRead.AttributeId,
nodeToRead.ParsedIndexRange,
nodeToRead.DataEncoding,
value);
continue;
}
ReadValueId request = (ReadValueId)nodeToRead.Clone();
request.NodeId = m_mapper.ToRemoteId(nodeToRead.NodeId);
request.DataEncoding = m_mapper.ToRemoteName(nodeToRead.DataEncoding);
requests.Add(request);
indexes.Add(ii);
}
}
// send request to external system.
try
{
Opc.Ua.Client.Session client = GetClientSession(context);
DataValueCollection results = null;
DiagnosticInfoCollection diagnosticInfos = null;
ResponseHeader responseHeader = client.Read(
null,
0,
TimestampsToReturn.Both,
requests,
out results,
out diagnosticInfos);
// these do sanity checks on the result - make sure response matched the request.
ClientBase.ValidateResponse(results, requests);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, requests);
// set results.
for (int ii = 0; ii < requests.Count; ii++)
{
values[indexes[ii]] = results[ii];
values[indexes[ii]].WrappedValue = m_mapper.ToLocalVariant(results[ii].WrappedValue);
errors[indexes[ii]] = ServiceResult.Good;
if (results[ii].StatusCode != StatusCodes.Good)
{
errors[indexes[ii]] = new ServiceResult(results[ii].StatusCode, ii, diagnosticInfos, responseHeader.StringTable);
}
}
}
catch (Exception e)
{
// handle unexpected communication error.
ServiceResult error = ServiceResult.Create(e, StatusCodes.BadUnexpectedError, "Could not access external system.");
for (int ii = 0; ii < requests.Count; ii++)
{
errors[indexes[ii]] = error;
}
}
}
/// <summary>
/// Reads the values for the specified item ids.
/// </summary>
/// <param name="itemIds">The item ids.</param>
/// <returns>The values.</returns>
public DaValue[] Read(string[] itemIds)
{
ReadValueIdCollection valuesToRead = new ReadValueIdCollection();
for (int ii = 0; ii < itemIds.Length; ii++)
{
ReadValueId valueToRead = new ReadValueId();
valueToRead.NodeId = m_mapper.GetRemoteNodeId(itemIds[ii]);
valueToRead.AttributeId = Attributes.Value;
valuesToRead.Add(valueToRead);
}
return m_groupManager.Read(valuesToRead);
}
/// <summary>
/// Adds the attributes to the control.
/// </summary>
private void AddAttributes()
{
// build list of attributes to read.
ReadValueIdCollection nodesToRead = new ReadValueIdCollection();
foreach (uint attributeId in Attributes.GetIdentifiers())
{
ReadValueId valueId = new ReadValueId();
valueId.NodeId = m_nodeId;
valueId.AttributeId = attributeId;
valueId.IndexRange = null;
valueId.DataEncoding = null;
nodesToRead.Add(valueId);
}
// read attributes.
DataValueCollection values;
DiagnosticInfoCollection diagnosticInfos;
m_session.Read(
null,
0,
TimestampsToReturn.Neither,
nodesToRead,
out values,
out diagnosticInfos);
ClientBase.ValidateResponse(values, nodesToRead);
ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToRead);
// update control.
for (int ii = 0; ii < nodesToRead.Count; ii++)
{
// check if node supports attribute.
if (values[ii].StatusCode == StatusCodes.BadAttributeIdInvalid)
{
continue;
}
NodeField field = new NodeField();
field.ValueId = nodesToRead[ii];
field.Name = Attributes.GetBrowseName(nodesToRead[ii].AttributeId);
field.Value = values[ii].Value;
field.StatusCode = values[ii].StatusCode;
if (diagnosticInfos != null && diagnosticInfos.Count > ii)
{
field.DiagnosticInfo = diagnosticInfos[ii];
}
AddItem(field, "SimpleItem", -1);
}
}
