/// <summary>
/// Ensures the data value contains a value with the specified type.
/// </summary>
public object GetValue(Type expectedType) {
object value = this.Value;
if (expectedType != null) {
ExtensionObject extension = value as ExtensionObject;
if (extension != null) {
value = extension.Body;
}
if (!expectedType.IsInstanceOfType(value)) {
throw ServiceResultException.Create(StatusCodes.BadTypeMismatch, "DataValue is not of type {0}.",
expectedType.Name);
}
}
return value;
}
/// <summary>
/// Invokes the HistoryRead service.
/// </summary>
public virtual ResponseHeader HistoryRead(
RequestHeader requestHeader,
ExtensionObject historyReadDetails,
TimestampsToReturn timestampsToReturn,
bool releaseContinuationPoints,
HistoryReadValueIdCollection nodesToRead,
out HistoryReadResultCollection results,
out DiagnosticInfoCollection diagnosticInfos)
{
results = null;
diagnosticInfos = null;
ValidateRequest(requestHeader);
// Insert implementation.
return(CreateResponse(requestHeader, StatusCodes.BadServiceUnsupported));
}
/// <summary>
/// Gets the value from the data value.
/// </summary>
/// <typeparam name="T">The type of object.</typeparam>
/// <param name="defaultValue">The default value to return if any error occurs.</param>
/// <returns>The value.</returns>
/// <remarks>
/// Does not throw exceptions; returns the caller provided value instead.
/// Extracts the body from an ExtensionObject value if it has the correct type.
/// Checks the StatusCode and returns an error if not Good.
/// </remarks>
public T GetValue<T>(T defaultValue) {
if (StatusCode.IsNotGood(this.StatusCode)) {
return defaultValue;
}
if (typeof(T).IsInstanceOfType(this.Value)) {
return (T) this.Value;
}
ExtensionObject extension = this.Value as ExtensionObject;
if (extension != null) {
if (typeof(T).IsInstanceOfType(extension.Body)) {
return (T) extension.Body;
}
}
return defaultValue;
}
/// <summary>
/// Invokes the ActivateSession service.
/// </summary>
public virtual ResponseHeader ActivateSession(
RequestHeader requestHeader,
SignatureData clientSignature,
SignedSoftwareCertificateCollection clientSoftwareCertificates,
StringCollection localeIds,
ExtensionObject userIdentityToken,
SignatureData userTokenSignature,
out byte[] serverNonce,
out StatusCodeCollection results,
out DiagnosticInfoCollection diagnosticInfos)
{
serverNonce = null;
results = null;
diagnosticInfos = null;
ValidateRequest(requestHeader);
// Insert implementation.
return(CreateResponse(requestHeader, StatusCodes.BadServiceUnsupported));
}
/// <summary>
/// Determines if the specified object is equal to the <paramref name="obj"/>.
/// </summary>
/// <param name="obj">The object to compare to this instance of object</param>
/// <returns>
/// true if the specified <see cref="T:System.Object"/> is equal to the current embeded object; otherwise, false.
/// </returns>
public override bool Equals(object obj) {
if (Object.ReferenceEquals(obj, null)) {
return IsNull(this);
}
if (Object.ReferenceEquals(this, obj)) {
return true;
}
ExtensionObject value = obj as ExtensionObject;
if (value != null) {
if (this.m_typeId != value.m_typeId) {
return false;
}
return Utils.IsEqual(this.m_body, value.m_body);
}
return false;
}
/// <summary>
/// Returns the operands for the element.
/// </summary>
/// <returns>The list of operands for the element.</returns>
public List <FilterOperand> GetOperands()
{
List <FilterOperand> operands = new List <FilterOperand>(FilterOperands.Count);
foreach (ExtensionObject extension in FilterOperands)
{
if (ExtensionObject.IsNull(extension))
{
continue;
}
FilterOperand operand = extension.Body as FilterOperand;
if (operand == null)
{
continue;
}
operands.Add(operand);
}
return(operands);
}
/// <summary>
/// Reads the value for DataTypeDefinition attribute.
/// </summary>
protected override ServiceResult ReadNonValueAttribute(
ISystemContext context,
uint attributeId,
ref object value)
{
ServiceResult result = null;
switch (attributeId)
{
case Attributes.DataTypeDefinition:
{
ExtensionObject dataTypeDefinition = m_dataTypeDefinition;
if (OnReadDataTypeDefinition != null)
{
result = OnReadDataTypeDefinition(context, this, ref dataTypeDefinition);
}
if (ServiceResult.IsGood(result))
{
if (dataTypeDefinition?.Body is StructureDefinition structureType &&
(structureType.DefaultEncodingId == null ||
structureType.DefaultEncodingId.IsNullNodeId))
{
// one time set the id for binary encoding, currently the only supported encoding
structureType.SetDefaultEncodingId(context, NodeId, null);
}
value = dataTypeDefinition;
}
return(result);
}
}
return(base.ReadNonValueAttribute(context, attributeId, ref value));
}
/// <summary>
/// Reads the history of values for a set of variables at given time.
/// </summary>
static void HistoryReadAtTime(Session session)
{
// translate browse paths.
IList<NodeOfInterest> nodeIds = GetNodeIds(session, Opc.Ua.Objects.ObjectsFolder,
VariableBrowsePaths.ToArray());
DiagnosticInfoCollection diagnosticInfos;
ReadAtTimeDetails readDetails = new ReadAtTimeDetails();
readDetails.ReqTimes = new DateTimeCollection();
for (int jj = 0; jj < 10; jj++)
{
readDetails.ReqTimes.Add(new DateTime(2008, 01, 01, 12, 0, jj));
readDetails.ReqTimes.Add(new DateTime(2008, 01, 01, 12, 0, jj, (int) 500));
}
ExtensionObject eo = new ExtensionObject(readDetails.TypeId, readDetails);
HistoryReadValueIdCollection idCollection = new HistoryReadValueIdCollection();
for (int ii = 0; ii < nodeIds.Count; ii++)
{
HistoryReadValueId readValueId = new HistoryReadValueId();
readValueId.NodeId = nodeIds[ii].NodeId;
readValueId.Processed = false;
idCollection.Add(readValueId);
}
HistoryReadResultCollection historyReadResults;
ResponseHeader responseHeader =
session.HistoryRead(null, eo, TimestampsToReturn.Both, true,
idCollection, out historyReadResults, out diagnosticInfos);
// process results.
for (int ii = 0; ii < historyReadResults.Count; ii++)
{
HistoryReadResult historyReadResult = historyReadResults[ii];
HistoryData historyData = null;
DataValueCollection dataValues = null;
if (historyReadResult.HistoryData != null)
{
historyData = ExtensionObject.ToEncodeable(historyReadResult.HistoryData) as HistoryData;
dataValues = historyData.DataValues;
}
ServiceResult result = Session.GetResult(historyReadResult.StatusCode, ii, diagnosticInfos, responseHeader);
Console.WriteLine("HistoryRead result code for {0}: {1}", VariableBrowsePaths[ii], result.StatusCode.ToString());
if (StatusCode.IsBad(historyReadResult.StatusCode))
{
continue;
}
if (dataValues == null)
{
Console.WriteLine("dataValues == null");
continue;
}
for (int jj = 0; jj < dataValues.Count; jj++)
{
DataValue dataValue = dataValues[jj];
// write value.
Console.WriteLine("{0}: V={1}, Q={2}, SrvT={3}, SrcT={4}", jj,
dataValue.Value == null ? "null" : dataValue.Value.ToString(),
dataValue.StatusCode.ToString(),
dataValue.ServerTimestamp, dataValue.SourceTimestamp);
}
}
}
/// <summary>
/// Invokes the HistoryRead service.
/// </summary>
public virtual ResponseHeader HistoryRead(
RequestHeader requestHeader,
ExtensionObject historyReadDetails,
TimestampsToReturn timestampsToReturn,
bool releaseContinuationPoints,
HistoryReadValueIdCollection nodesToRead,
out HistoryReadResultCollection results,
out DiagnosticInfoCollection diagnosticInfos)
{
HistoryReadRequest request = new HistoryReadRequest();
HistoryReadResponse response = null;
request.RequestHeader = requestHeader;
request.HistoryReadDetails = historyReadDetails;
request.TimestampsToReturn = timestampsToReturn;
request.ReleaseContinuationPoints = releaseContinuationPoints;
request.NodesToRead = nodesToRead;
UpdateRequestHeader(request, requestHeader == null, "HistoryRead");
try
{
if (UseTransportChannel)
{
IServiceResponse genericResponse = TransportChannel.SendRequest(request);
if (genericResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
ValidateResponse(genericResponse.ResponseHeader);
response = (HistoryReadResponse)genericResponse;
}
else
{
HistoryReadResponseMessage responseMessage = InnerChannel.HistoryRead(new HistoryReadMessage(request));
if (responseMessage == null || responseMessage.HistoryReadResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
response = responseMessage.HistoryReadResponse;
ValidateResponse(response.ResponseHeader);
}
results = response.Results;
diagnosticInfos = response.DiagnosticInfos;
}
finally
{
RequestCompleted(request, response, "HistoryRead");
}
return response.ResponseHeader;
}
/// <summary>
/// Converts a remote ExtensionObject to a local ExtensionObject.
/// </summary>
public ExtensionObject ToLocalExtensionObject(ExtensionObject value)
{
return ToExtensionObject(value, m_localNamespaceIndexes);
}
/// <summary>
/// Invokes the HistoryRead service.
/// </summary>
public virtual ResponseHeader HistoryRead(
RequestHeader requestHeader,
ExtensionObject historyReadDetails,
TimestampsToReturn timestampsToReturn,
bool releaseContinuationPoints,
HistoryReadValueIdCollection nodesToRead,
out HistoryReadResultCollection results,
out DiagnosticInfoCollection diagnosticInfos)
{
results = null;
diagnosticInfos = null;
ValidateRequest(requestHeader);
// Insert implementation.
return CreateResponse(requestHeader, StatusCodes.BadServiceUnsupported);
}
/// <summary>
/// Converts a local ExtensionObject to a remote ExtensionObject.
/// </summary>
public ExtensionObject ToRemoteExtensionObject(ExtensionObject value)
{
return ToExtensionObject(value, m_remoteNamespaceIndexes);
}
/// <summary>
/// Adds the value to the XML element.
/// </summary>
private VariantValue CreateScalar(XmlDocument document, object value)
{
VariantValue variant = new VariantValue();
if (value == null)
{
return(variant);
}
XmlElement element = null;
switch (value.GetType().Name)
{
case "Boolean":
{
element = document.CreateElement("Boolean", Namespaces.OpcUaXsd);
element.InnerText = XmlConvert.ToString((bool)value);
break;
}
case "Byte":
{
element = document.CreateElement("Byte", Namespaces.OpcUaXsd);
element.InnerText = XmlConvert.ToString((byte)value);
break;
}
case "SByte":
{
element = document.CreateElement("SByte", Namespaces.OpcUaXsd);
element.InnerText = XmlConvert.ToString((sbyte)value);
break;
}
case "Int16":
{
element = document.CreateElement("Int16", Namespaces.OpcUaXsd);
element.InnerText = XmlConvert.ToString((short)value);
break;
}
case "UInt16":
{
element = document.CreateElement("UInt16", Namespaces.OpcUaXsd);
element.InnerText = XmlConvert.ToString((ushort)value);
break;
}
case "Int32":
{
element = document.CreateElement("Int32", Namespaces.OpcUaXsd);
element.InnerText = XmlConvert.ToString((int)value);
break;
}
case "UInt32":
{
element = document.CreateElement("UInt32", Namespaces.OpcUaXsd);
element.InnerText = XmlConvert.ToString((uint)value);
break;
}
case "Int64":
{
element = document.CreateElement("Int64", Namespaces.OpcUaXsd);
element.InnerText = XmlConvert.ToString((long)value);
break;
}
case "UInt64":
{
element = document.CreateElement("UInt64", Namespaces.OpcUaXsd);
element.InnerText = XmlConvert.ToString((ulong)value);
break;
}
case "Single":
{
element = document.CreateElement("Float", Namespaces.OpcUaXsd);
element.InnerText = XmlConvert.ToString((float)value);
break;
}
case "Double":
{
element = document.CreateElement("Double", Namespaces.OpcUaXsd);
element.InnerText = XmlConvert.ToString((double)value);
break;
}
case "String":
{
element = document.CreateElement("String", Namespaces.OpcUaXsd);
element.InnerText = (string)value;
break;
}
case "DateTime":
{
element = document.CreateElement("DateTime", Namespaces.OpcUaXsd);
element.InnerText = XmlConvert.ToString((DateTime)value, XmlDateTimeSerializationMode.Utc);
break;
}
case "NodeId":
{
element = document.CreateElement("NodeId", Namespaces.OpcUaXsd);
AddChild(document, element, "Identifier", ((NodeId)value).Identifier);
break;
}
case "ExpandedNodeId":
{
element = document.CreateElement("ExpandedNodeId", Namespaces.OpcUaXsd);
AddChild(document, element, "Identifier", ((ExpandedNodeId)value).Identifier);
break;
}
case "QualifiedName":
{
element = document.CreateElement("QualifiedName", Namespaces.OpcUaXsd);
AddChild(document, element, "NamespaceIndex", XmlConvert.ToString(((QualifiedName)value).NamespaceIndex));
AddChild(document, element, "Name", ((QualifiedName)value).Name);
break;
}
case "LocalizedText":
{
element = document.CreateElement("LocalizedText", Namespaces.OpcUaXsd);
AddChild(document, element, "Locale", ((LocalizedText)value).Locale);
AddChild(document, element, "Text", ((LocalizedText)value).Text);
break;
}
case "StatusCode":
{
element = document.CreateElement("StatusCode", Namespaces.OpcUaXsd);
uint?code = ((StatusCode)value).Code;
if (code != null && code.Value != StatusCodes.Good)
{
AddChild(document, element, "Code", XmlConvert.ToString(code.Value));
}
break;
}
case "ExtensionObject":
{
element = document.CreateElement("ExtensionObject", Namespaces.OpcUaXsd);
ExtensionObject extension = (ExtensionObject)value;
if (extension != null)
{
XmlElement typeId = document.CreateElement("TypeId", Namespaces.OpcUaXsd);
element.AppendChild(typeId);
AddChild(document, typeId, "Identifier", extension.TypeId.Identifier);
XmlElement body = document.CreateElement("Body", Namespaces.OpcUaXsd);
if (extension.Body != null && extension.Body.Nodes != null && extension.Body.Nodes.Length > 0)
{
body.InnerXml = extension.Body.Nodes[0].OuterXml;
}
element.AppendChild(body);
}
break;
}
}
variant.Nodes = new XmlNode[] { element };
return(variant);
}
private ServiceResult OnArrayValue3(
ISystemContext context,
MethodState method,
NodeId objectId,
Variant[] variantIn,
int[] enumerationIn,
ExtensionObject[] structureIn,
ref Variant[] variantOut,
ref int[] enumerationOut,
ref ExtensionObject[] structureOut)
{
variantOut = variantIn;
enumerationOut = enumerationIn;
structureOut = structureIn;
return ServiceResult.Good;
}
/// <summary cref="ITypeTable.IsEncodingFor(NodeId, ExtensionObject)" />
public bool IsEncodingFor(NodeId expectedTypeId, ExtensionObject value)
{
// no match on null values.
if (value == null)
{
return false;
}
// may still match if the extension type is an encoding for the expected type.
if (IsEncodingOf(value.TypeId, expectedTypeId))
{
return true;
}
// no match.
return false;
}
public bool WriteUDT(List <string> opcNodes, List <object> values, out List <bool> status)
{
bool ret = false;
try
{
if (opcNodes.Count != values.Count)
{
throw new Exception("opcNodes.Count != values.Count");
}
int count = opcNodes.Count;
status = new List <bool>(count);
List <Type> types = new List <Type>(count);
List <NodeId> nodeIds = new List <NodeId>(count);
DiagnosticInfoCollection diags;
StatusCodeCollection statusCodes;
WriteValueCollection writeValues = new WriteValueCollection(count);
for (int i = 0; i < count; i++)
{
//Variant variant = new Variant(values[i]);
Opc.Ua.ExpandedNodeId expNodeId = new Opc.Ua.ExpandedNodeId(opcNodes[i]);
Opc.Ua.ExtensionObject extObj = new Opc.Ua.ExtensionObject(expNodeId, values[i]);
DataValue dataVal = new DataValue(extObj);
WriteValue writeVal = new WriteValue();
//writeVal.
writeVal.Value = dataVal;
writeVal.NodeId = new NodeId(opcNodes[i]);
writeVal.AttributeId = Attributes.Value;
writeValues.Add(writeVal);
}
ResponseHeader rh = session.Write(null, writeValues, out statusCodes, out diags);
ret = StatusCode.IsGood(rh.ServiceResult.Code);
for (int i = 0; i < count; i++)
{
//status[i] = StatusCode.IsGood(statusCodes[i]);
status.Add(StatusCode.IsGood(statusCodes[i]));
ret = ret & status[i];
}
}
catch (Exception ex)
{
ret = false;
status = null;
System.Diagnostics.Debug.WriteLine("Exception OpcUaClient::WriteValues " + ex.Message);
}
return(ret);
}
public Variant ReadVariant(string fieldName)
{
// read the encoding byte.
byte encodingByte = m_reader.ReadByte();
Variant value = new Variant();
if ((encodingByte & (byte)VariantArrayEncodingBits.Array) != 0)
{
// read the array length.
int length = m_reader.ReadInt32();
if (length < 0)
{
return value;
}
Array array = null;
BuiltInType builtInType = (BuiltInType)(encodingByte & (byte)VariantArrayEncodingBits.TypeMask);
switch (builtInType)
{
case BuiltInType.Boolean:
{
bool[] values = new bool[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadBoolean(null);
}
array = values;
break;
}
case BuiltInType.SByte:
{
sbyte[] values = new sbyte[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadSByte(null);
}
array = values;
break;
}
case BuiltInType.Byte:
{
byte[] values = new byte[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadByte(null);
}
array = values;
break;
}
case BuiltInType.Int16:
{
short[] values = new short[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadInt16(null);
}
array = values;
break;
}
case BuiltInType.UInt16:
{
ushort[] values = new ushort[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadUInt16(null);
}
array = values;
break;
}
case BuiltInType.Int32:
case BuiltInType.Enumeration:
{
int[] values = new int[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadInt32(null);
}
array = values;
break;
}
case BuiltInType.UInt32:
{
uint[] values = new uint[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadUInt32(null);
}
array = values;
break;
}
case BuiltInType.Int64:
{
long[] values = new long[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadInt64(null);
}
array = values;
break;
}
case BuiltInType.UInt64:
{
ulong[] values = new ulong[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadUInt64(null);
}
array = values;
break;
}
case BuiltInType.Float:
{
float[] values = new float[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadFloat(null);
}
array = values;
break;
}
case BuiltInType.Double:
{
double[] values = new double[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadDouble(null);
}
array = values;
break;
}
case BuiltInType.String:
{
string[] values = new string[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadString(null);
}
array = values;
break;
}
case BuiltInType.DateTime:
{
DateTime[] values = new DateTime[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadDateTime(null);
}
array = values;
break;
}
case BuiltInType.Guid:
{
Uuid[] values = new Uuid[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadGuid(null);
}
array = values;
break;
}
case BuiltInType.ByteString:
{
byte[][] values = new byte[length][];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadByteString(null);
}
array = values;
break;
}
case BuiltInType.XmlElement:
{
try
{
XmlElement[] values = new XmlElement[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadXmlElement(null);
}
array = values;
}
catch(Exception ex)
{
Utils.Trace(ex, "Error reading variant.");
}
break;
}
case BuiltInType.NodeId:
{
NodeId[] values = new NodeId[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadNodeId(null);
}
array = values;
break;
}
case BuiltInType.ExpandedNodeId:
{
ExpandedNodeId[] values = new ExpandedNodeId[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadExpandedNodeId(null);
}
array = values;
break;
}
case BuiltInType.StatusCode:
{
StatusCode[] values = new StatusCode[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadStatusCode(null);
}
array = values;
break;
}
case BuiltInType.QualifiedName:
{
QualifiedName[] values = new QualifiedName[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadQualifiedName(null);
}
array = values;
break;
}
case BuiltInType.LocalizedText:
{
LocalizedText[] values = new LocalizedText[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadLocalizedText(null);
}
array = values;
break;
}
case BuiltInType.ExtensionObject:
{
ExtensionObject[] values = new ExtensionObject[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadExtensionObject();
}
array = values;
break;
}
case BuiltInType.DataValue:
{
DataValue[] values = new DataValue[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadDataValue(null);
}
array = values;
break;
}
case BuiltInType.Variant:
{
Variant[] values = new Variant[length];
for (int ii = 0; ii < values.Length; ii++)
{
values[ii] = ReadVariant(null);
}
array = values;
break;
}
default:
{
throw new ServiceResultException(
StatusCodes.BadDecodingError,
Utils.Format("Cannot decode unknown type in Variant object (0x{0:X2}).", encodingByte));
}
}
if (array == null)
{
value = new Variant(StatusCodes.BadEncodingError);
}
else
{
// check for multi-dimensional arrays.
if ((encodingByte & (byte)VariantArrayEncodingBits.ArrayDimensions) != 0)
{
Int32Collection dimensions = ReadInt32Array(null);
if (dimensions != null && dimensions.Count > 0)
{
value = new Variant(new Matrix(array, builtInType, dimensions.ToArray()));
}
else
{
value = new Variant(new Matrix(array, builtInType));
}
}
else
{
value = new Variant(array);
}
}
}
else
{
switch ((BuiltInType)encodingByte)
{
case BuiltInType.Null:
{
value.Value = null;
break;
}
case BuiltInType.Boolean:
{
value.Set(ReadBoolean(null));
break;
}
case BuiltInType.SByte:
{
value.Set(ReadSByte(null));
break;
}
case BuiltInType.Byte:
{
value.Set(ReadByte(null));
break;
}
case BuiltInType.Int16:
{
value.Set(ReadInt16(null));
break;
}
case BuiltInType.UInt16:
{
value.Set(ReadUInt16(null));
break;
}
case BuiltInType.Int32:
case BuiltInType.Enumeration:
{
value.Set(ReadInt32(null));
break;
}
case BuiltInType.UInt32:
{
value.Set(ReadUInt32(null));
break;
}
case BuiltInType.Int64:
{
value.Set(ReadInt64(null));
break;
}
case BuiltInType.UInt64:
{
value.Set(ReadUInt64(null));
break;
}
case BuiltInType.Float:
{
value.Set(ReadFloat(null));
break;
}
case BuiltInType.Double:
{
value.Set(ReadDouble(null));
break;
}
case BuiltInType.String:
{
value.Set(ReadString(null));
break;
}
case BuiltInType.DateTime:
{
value.Set(ReadDateTime(null));
break;
}
case BuiltInType.Guid:
{
value.Set(ReadGuid(null));
break;
}
case BuiltInType.ByteString:
{
value.Set(ReadByteString(null));
break;
}
case BuiltInType.XmlElement:
{
try
{
value.Set(ReadXmlElement(null));
}
catch(Exception ex)
{
Utils.Trace(ex, "Error reading xml element for variant.");
value.Set(StatusCodes.BadEncodingError);
}
break;
}
case BuiltInType.NodeId:
{
value.Set(ReadNodeId(null));
break;
}
case BuiltInType.ExpandedNodeId:
{
value.Set(ReadExpandedNodeId(null));
break;
}
case BuiltInType.StatusCode:
{
value.Set(ReadStatusCode(null));
break;
}
case BuiltInType.QualifiedName:
{
value.Set(ReadQualifiedName(null));
break;
}
case BuiltInType.LocalizedText:
{
value.Set(ReadLocalizedText(null));
break;
}
case BuiltInType.ExtensionObject:
{
value.Set(ReadExtensionObject());
break;
}
case BuiltInType.DataValue:
{
value.Set(ReadDataValue(null));
break;
}
default:
{
throw new ServiceResultException(
StatusCodes.BadDecodingError,
Utils.Format("Cannot decode unknown type in Variant object (0x{0:X2}).", encodingByte));
}
}
}
return value;
}
/// <summary>
/// Reads an extension object from the stream.
/// </summary>
private ExtensionObject ReadExtensionObject()
{
ExtensionObject extension = new ExtensionObject();
// read type id.
NodeId typeId = ReadNodeId(null);
// convert to absolute node id.
extension.TypeId = NodeId.ToExpandedNodeId(typeId, m_context.NamespaceUris);
if (!NodeId.IsNull(typeId) && NodeId.IsNull(extension.TypeId))
{
Utils.Trace(
"Cannot de-serialized extension objects if the NamespaceUri is not in the NamespaceTable: Type = {0}",
typeId);
}
// read encoding.
ExtensionObjectEncoding encoding = (ExtensionObjectEncoding)Enum.ToObject(typeof(ExtensionObjectEncoding), m_reader.ReadByte());
// nothing more to do for empty bodies.
if (encoding == ExtensionObjectEncoding.None)
{
return extension;
}
// check for known type.
Type systemType = m_context.Factory.GetSystemType(extension.TypeId);
// check for XML bodies.
if (encoding == ExtensionObjectEncoding.Xml)
{
extension.Body = ReadXmlElement(null);
// attempt to decode a known type.
if (systemType != null)
{
XmlElement element = extension.Body as XmlElement;
XmlDecoder xmlDecoder = new XmlDecoder(element, this.Context);
try
{
xmlDecoder.PushNamespace(element.NamespaceURI);
IEncodeable body = xmlDecoder.ReadEncodeable(element.LocalName, systemType);
xmlDecoder.PopNamespace();
// update body.
extension.Body = body;
}
catch (Exception e)
{
Utils.Trace("Could not decode known type {0}. Error={1}, Value={2}", systemType.FullName, e.Message, element.OuterXml);
}
}
return extension;
}
// create instance of type.
IEncodeable encodeable = null;
if (systemType != null)
{
encodeable = Activator.CreateInstance(systemType) as IEncodeable;
}
// get the length.
int length = ReadInt32(null);
// process unknown type.
if (encodeable == null)
{
// figure out how long the object is.
if (length == -1)
{
throw new ServiceResultException(
StatusCodes.BadDecodingError,
Utils.Format("Cannot determine length of unknown extension object body with type '{0}'.", extension.TypeId));
}
// check the length.
if (m_context.MaxByteStringLength > 0 && m_context.MaxByteStringLength < length)
{
throw ServiceResultException.Create(
StatusCodes.BadEncodingLimitsExceeded,
"MaxByteStringLength {0} < {1}",
m_context.MaxByteStringLength,
length);
}
// read the bytes of the body.
extension.Body = m_reader.ReadBytes(length);
return extension;
}
// save the current position.
int start = Position;
// decode body.
encodeable.Decode(this);
// skip any unread data.
int unused = length - (Position - start);
if (unused > 0)
{
m_reader.ReadBytes(unused);
}
extension.Body = encodeable;
return extension;
}
/// <summary>
/// Begins an asynchronous invocation of the ActivateSession service.
/// </summary>
public IAsyncResult BeginActivateSession(
RequestHeader requestHeader,
SignatureData clientSignature,
SignedSoftwareCertificateCollection clientSoftwareCertificates,
StringCollection localeIds,
ExtensionObject userIdentityToken,
SignatureData userTokenSignature,
AsyncCallback callback,
object asyncState)
{
ActivateSessionRequest request = new ActivateSessionRequest();
request.RequestHeader = requestHeader;
request.ClientSignature = clientSignature;
request.ClientSoftwareCertificates = clientSoftwareCertificates;
request.LocaleIds = localeIds;
request.UserIdentityToken = userIdentityToken;
request.UserTokenSignature = userTokenSignature;
UpdateRequestHeader(request, requestHeader == null, "ActivateSession");
if (UseTransportChannel)
{
return TransportChannel.BeginSendRequest(request, callback, asyncState);
}
return InnerChannel.BeginActivateSession(new ActivateSessionMessage(request), callback, asyncState);
}
/// <summary>
/// Invokes the ActivateSession service.
/// </summary>
public virtual ResponseHeader ActivateSession(
RequestHeader requestHeader,
SignatureData clientSignature,
SignedSoftwareCertificateCollection clientSoftwareCertificates,
StringCollection localeIds,
ExtensionObject userIdentityToken,
SignatureData userTokenSignature,
out byte[] serverNonce,
out StatusCodeCollection results,
out DiagnosticInfoCollection diagnosticInfos)
{
ActivateSessionRequest request = new ActivateSessionRequest();
ActivateSessionResponse response = null;
request.RequestHeader = requestHeader;
request.ClientSignature = clientSignature;
request.ClientSoftwareCertificates = clientSoftwareCertificates;
request.LocaleIds = localeIds;
request.UserIdentityToken = userIdentityToken;
request.UserTokenSignature = userTokenSignature;
UpdateRequestHeader(request, requestHeader == null, "ActivateSession");
try
{
if (UseTransportChannel)
{
IServiceResponse genericResponse = TransportChannel.SendRequest(request);
if (genericResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
ValidateResponse(genericResponse.ResponseHeader);
response = (ActivateSessionResponse)genericResponse;
}
else
{
ActivateSessionResponseMessage responseMessage = InnerChannel.ActivateSession(new ActivateSessionMessage(request));
if (responseMessage == null || responseMessage.ActivateSessionResponse == null)
{
throw new ServiceResultException(StatusCodes.BadUnknownResponse);
}
response = responseMessage.ActivateSessionResponse;
ValidateResponse(response.ResponseHeader);
}
serverNonce = response.ServerNonce;
results = response.Results;
diagnosticInfos = response.DiagnosticInfos;
}
finally
{
RequestCompleted(request, response, "ActivateSession");
}
return response.ResponseHeader;
}
/// <summary>
/// Begins an asynchronous invocation of the HistoryRead service.
/// </summary>
public IAsyncResult BeginHistoryRead(
RequestHeader requestHeader,
ExtensionObject historyReadDetails,
TimestampsToReturn timestampsToReturn,
bool releaseContinuationPoints,
HistoryReadValueIdCollection nodesToRead,
AsyncCallback callback,
object asyncState)
{
HistoryReadRequest request = new HistoryReadRequest();
request.RequestHeader = requestHeader;
request.HistoryReadDetails = historyReadDetails;
request.TimestampsToReturn = timestampsToReturn;
request.ReleaseContinuationPoints = releaseContinuationPoints;
request.NodesToRead = nodesToRead;
UpdateRequestHeader(request, requestHeader == null, "HistoryRead");
if (UseTransportChannel)
{
return TransportChannel.BeginSendRequest(request, callback, asyncState);
}
return InnerChannel.BeginHistoryRead(new HistoryReadMessage(request), callback, asyncState);
}
/// <summary>
/// Deletes the history of values for a set of variables at given time interval.
/// </summary>
static void HistoryDeleteRaw(Session session)
{
// translate browse paths.
IList<NodeOfInterest> results = GetNodeIds(session, Opc.Ua.Objects.ObjectsFolder,
VariableBrowsePaths.ToArray());
DiagnosticInfoCollection diagnosticInfos;
ExtensionObjectCollection eoc = new ExtensionObjectCollection();
for (int ii = 0; ii < results.Count; ii++)
{
DeleteRawModifiedDetails deleteDetails = new DeleteRawModifiedDetails();
deleteDetails.StartTime = new DateTime(2008, 1, 1, 12, 0, 0);
deleteDetails.EndTime = new DateTime(2008, 1, 1, 12, 0, 10);
deleteDetails.NodeId = results[ii].NodeId;
deleteDetails.IsDeleteModified = false;
ExtensionObject eo = new ExtensionObject(deleteDetails.TypeId, deleteDetails);
eoc.Add(eo);
}
HistoryUpdateResultCollection historyUpdateResults;
ResponseHeader responseHeader =
session.HistoryUpdate(null, eoc, out historyUpdateResults, out diagnosticInfos);
// process results.
for (int ii = 0; ii < historyUpdateResults.Count; ii++)
{
HistoryUpdateResult historyUpdateResult = historyUpdateResults[ii];
Console.WriteLine("HistoryUpdate result code for {0}: {1}", VariableBrowsePaths[ii], historyUpdateResult.StatusCode.ToString());
if (StatusCode.IsGood(historyUpdateResult.StatusCode))
{
for (int jj = 0; jj < historyUpdateResult.OperationResults.Count; jj++)
{
Console.WriteLine(" {0}: {1}", jj, historyUpdateResult.OperationResults[jj]);
}
Console.WriteLine("");
}
}
}
static void HistoryReadProcessed(Session session)
{
// translate browse paths.
IList<NodeOfInterest> nodeIds = GetNodeIds(session, Opc.Ua.Objects.ObjectsFolder,
VariableBrowsePaths.ToArray());
DiagnosticInfoCollection diagnosticInfos;
NodeId aggregateNodeId = null;
RequestHeader rh = null;
ViewDescription vd = null;
ReferenceDescriptionCollection references;
byte[] cp;
//Get the list of avalilable aggregate functions:
session.Browse(
rh,
vd,
Opc.Ua.ObjectIds.Server_ServerCapabilities_AggregateFunctions,
1000,
BrowseDirection.Forward,
ReferenceTypeIds.Aggregates,
false,
0,
out cp,
out references);
Console.WriteLine("{0} aggregates are detected:", references.Count);
//Print the list of avalible aggregates:
int i = 0;
foreach (ReferenceDescription rd in references)
{
i++;
Console.WriteLine("{0}. {1} {2}", i, rd.BrowseName, rd.NodeId.Identifier.ToString());
}
//Select aggregate function:
Console.WriteLine("\nEnter aggregate number: ");
string str = Console.ReadLine();
i = System.Int16.Parse(str);
if (i > 0 && i <= references.Count)
{
aggregateNodeId = ExpandedNodeId.ToNodeId(references[i - 1].NodeId, session.NamespaceUris);
}
//Prepare arguments to pass to read processed history
ReadProcessedDetails readDetails = new ReadProcessedDetails();
readDetails.StartTime = new DateTime(2008, 1, 1, 12, 0, 0);
readDetails.EndTime = new DateTime(2008, 1, 1, 12, 0, 12);
readDetails.AggregateType = new NodeIdCollection(nodeIds.Count);
for (int x = 0; x < nodeIds.Count; x++)
{
readDetails.AggregateType.Add (aggregateNodeId);
}
readDetails.ProcessingInterval = 500; //500 milliseconds
ExtensionObject eo = new ExtensionObject(readDetails.TypeId, readDetails);
HistoryReadValueIdCollection idCollection = new HistoryReadValueIdCollection();
for (int ii = 0; ii < nodeIds.Count; ii++)
{
HistoryReadValueId readValueId = new HistoryReadValueId();
readValueId.NodeId = nodeIds[ii].NodeId;
readValueId.Processed = true;
idCollection.Add(readValueId);
}
HistoryReadResultCollection historyReadResults;
//Read processed history:
ResponseHeader responseHeader =
session.HistoryRead(null, eo, TimestampsToReturn.Both, true,
idCollection, out historyReadResults, out diagnosticInfos);
//Print results:
for (int ii = 0; ii < historyReadResults.Count; ii++)
{
HistoryReadResult historyReadResult = historyReadResults[ii];
ServiceResult result = Session.GetResult(historyReadResult.StatusCode, ii, diagnosticInfos, responseHeader);
HistoryData historyData = null;
DataValueCollection dataValues = null;
if ( !(historyReadResult.HistoryData == null) )
{
historyData = ExtensionObject.ToEncodeable(historyReadResult.HistoryData) as HistoryData;
if (historyData == null)
dataValues = null;
else
dataValues = historyData.DataValues;
}
Console.WriteLine("\nHistoryRead result code for {0}: {1}", VariableBrowsePaths[ii], result.StatusCode.ToString());
if (dataValues == null)
{
Console.WriteLine("dataValues == null");
continue;
}
for (int jj = 0; jj < dataValues.Count; jj++)
{
DataValue dataValue = dataValues[jj];
if (dataValue == null)
continue;
// write value.
Console.WriteLine("{0}: V={1}, Q={2}, SrvT={3}, SrcT={4}", jj,
dataValue.Value == null ? "null" : dataValue.Value.ToString(),
dataValue.StatusCode.ToString(),
dataValue.ServerTimestamp, dataValue.SourceTimestamp);
}
}
}
/// <summary>
/// Writes an ExtensionObject to the stream.
/// </summary>
public void WriteExtensionObject(string fieldName, ExtensionObject value)
{
if (value == null || value.Encoding == ExtensionObjectEncoding.None)
{
WriteSimpleField(fieldName, null, false);
return;
}
PushStructure(fieldName);
if (value != null)
{
IEncodeable encodeable = value.Body as IEncodeable;
if (encodeable != null)
{
if (UseReversibleEncoding)
{
WriteExpandedNodeId("TypeId", encodeable.TypeId);
WriteEncodeable("Object", encodeable, null);
}
else
{
encodeable.Encode(this);
}
}
else
{
WriteExpandedNodeId("TypeId", value.TypeId);
if (value.Body != null)
{
if (value.Encoding == ExtensionObjectEncoding.Binary)
{
WriteByteString("Binary", value.Body as byte[]);
}
else if (value.Encoding == ExtensionObjectEncoding.Xml)
{
WriteXmlElement("Xml", value.Body as XmlElement);
}
}
}
}
PopStructure();
}
/// <summary>
/// Parses an XML element and returns the value contained in it.
/// </summary>
private object ToObject(XmlElement element)
{
switch (element.Name)
{
case "Byte":
{
return(XmlConvert.ToByte(element.InnerText));
}
case "SByte":
{
return(XmlConvert.ToSByte(element.InnerText));
}
case "Int16":
{
return(XmlConvert.ToInt16(element.InnerText));
}
case "UInt16":
{
return(XmlConvert.ToUInt16(element.InnerText));
}
case "Int32":
{
return(XmlConvert.ToInt32(element.InnerText));
}
case "UInt32":
{
return(XmlConvert.ToUInt32(element.InnerText));
}
case "Int64":
{
return(XmlConvert.ToInt64(element.InnerText));
}
case "UInt64":
{
return(XmlConvert.ToUInt64(element.InnerText));
}
case "Single":
{
return(XmlConvert.ToSingle(element.InnerText));
}
case "Double":
{
return(XmlConvert.ToDouble(element.InnerText));
}
case "String":
{
return(element.InnerText);
}
case "DateTime":
{
return(XmlConvert.ToDateTime(element.InnerText, XmlDateTimeSerializationMode.Utc));
}
case "NodeId":
{
XmlNode child = element.FirstChild;
string id = null;
if (GetValue(element, ref child, "Identifier", out id))
{
return(new NodeId(id));
}
break;
}
case "ExpandedNodeId":
{
XmlNode child = element.FirstChild;
string id = null;
if (GetValue(element, ref child, "Identifier", out id))
{
return(new NodeId(id));
}
break;
}
case "QualifiedName":
{
QualifiedName value = new QualifiedName();
XmlNode child = element.FirstChild;
string namespaceIndex = null;
if (GetValue(element, ref child, "NamespaceIndex", out namespaceIndex))
{
value.NamespaceIndex = XmlConvert.ToUInt16(namespaceIndex);
}
string name = null;
if (GetValue(element, ref child, "Name", out name))
{
value.Name = name;
}
return(value);
}
case "LocalizedText":
{
LocalizedText value = new LocalizedText();
XmlNode child = element.FirstChild;
string locale = null;
if (GetValue(element, ref child, "Locale", out locale))
{
value.Locale = locale;
}
string text = null;
if (GetValue(element, ref child, "Text", out text))
{
value.Text = text;
}
return(value);
}
case "StatusCode":
{
StatusCode value = new StatusCode();
XmlNode child = element.FirstChild;
string code = null;
if (GetValue(element, ref child, "Code", out code))
{
value.Code = XmlConvert.ToUInt32(code);;
}
return(value);
}
case "ExtensionObject":
{
ExtensionObject value = new ExtensionObject();
XmlNode child = element.FirstChild;
string typeId = null;
if (GetValue(element, ref child, "TypeId", out typeId))
{
value.TypeId = new ExpandedNodeId(typeId);
}
for (XmlNode node = child; node != null; node = node.NextSibling)
{
XmlElement element2 = child as XmlElement;
if (element2 != null)
{
if (element2.Name == "Body")
{
ExtensionObjectBody body = new ExtensionObjectBody();
body.Nodes = new XmlNode[] { GetFirstElement(element2) };
value.Body = body;
}
break;
}
}
return(value);
}
}
return(null);
}
/// <summary>
/// Validates the content filter element.
/// </summary>
/// <param name="context">The context.</param>
/// <param name="index">The index.</param>
/// <returns>The results of the validation.</returns>
public virtual ContentFilter.ElementResult Validate(FilterContext context, int index)
{
ContentFilter.ElementResult result = new ContentFilter.ElementResult(null);
// check the number of operands.
int operandCount = -1;
switch (m_filterOperator)
{
case FilterOperator.Not:
case FilterOperator.IsNull:
case FilterOperator.InView:
case FilterOperator.OfType:
{
operandCount = 1;
break;
}
case FilterOperator.And:
case FilterOperator.Or:
case FilterOperator.Equals:
case FilterOperator.GreaterThan:
case FilterOperator.GreaterThanOrEqual:
case FilterOperator.LessThan:
case FilterOperator.LessThanOrEqual:
case FilterOperator.Like:
case FilterOperator.Cast:
{
operandCount = 2;
break;
}
case FilterOperator.Between:
{
operandCount = 3;
break;
}
case FilterOperator.RelatedTo:
{
operandCount = 4;
break;
}
case FilterOperator.InList:
{
operandCount = -1;
break;
}
default:
{
break;
}
}
if (operandCount != -1)
{
if (operandCount != m_filterOperands.Count)
{
result.Status = ServiceResult.Create(
StatusCodes.BadEventFilterInvalid,
"ContentFilterElement does not have the correct number of operands (Operator={0} OperandCount={1}).",
m_filterOperator,
operandCount);
return(result);
}
}
else
{
if (m_filterOperands.Count < 2)
{
result.Status = ServiceResult.Create(
StatusCodes.BadEventFilterInvalid,
"ContentFilterElement does not have the correct number of operands (Operator={0} OperandCount={1}).",
m_filterOperator,
m_filterOperands.Count);
return(result);
}
}
// validate the operands.
bool error = false;
for (int ii = 0; ii < m_filterOperands.Count; ii++)
{
ServiceResult operandResult = null;
ExtensionObject operand = m_filterOperands[ii];
// check for null.
if (ExtensionObject.IsNull(operand))
{
operandResult = ServiceResult.Create(
StatusCodes.BadEventFilterInvalid,
"The FilterOperand cannot be Null.");
result.OperandResults.Add(operandResult);
error = true;
continue;
}
// check that the extension object contains a filter operand.
FilterOperand filterOperand = operand.Body as FilterOperand;
if (filterOperand == null)
{
operandResult = ServiceResult.Create(
StatusCodes.BadEventFilterInvalid,
"The FilterOperand is not a supported type ({0}).",
filterOperand.GetType());
result.OperandResults.Add(operandResult);
error = true;
continue;
}
// validate the operand.
filterOperand.Parent = this;
operandResult = filterOperand.Validate(context, index);
if (ServiceResult.IsBad(operandResult))
{
result.OperandResults.Add(operandResult);
error = true;
continue;
}
result.OperandResults.Add(null);
}
// ensure the global error code.
if (error)
{
result.Status = StatusCodes.BadContentFilterInvalid;
}
else
{
result.OperandResults.Clear();
}
return(result);
}
/// <summary>
/// Converts a remote ExtensionObject to a local ExtensionObject.
/// </summary>
private ExtensionObject ToExtensionObject(ExtensionObject extension, int[] namespaceIndexes)
{
if (ExtensionObject.IsNull(extension))
{
return extension;
}
Argument argument = extension.Body as Argument;
if (argument != null)
{
Argument argument2 = (Argument)argument.Clone();
argument2.DataType = ToId(argument.DataType, namespaceIndexes);
return new ExtensionObject(null, argument2);
}
return extension;
}
/// <summary>
/// Parses an XML element and returns the value contained in it.
/// </summary>
private object ToObject(XmlElement element)
{
switch (element.Name)
{
case "Byte":
{
return XmlConvert.ToByte(element.InnerText);
}
case "SByte":
{
return XmlConvert.ToSByte(element.InnerText);
}
case "Int16":
{
return XmlConvert.ToInt16(element.InnerText);
}
case "UInt16":
{
return XmlConvert.ToUInt16(element.InnerText);
}
case "Int32":
{
return XmlConvert.ToInt32(element.InnerText);
}
case "UInt32":
{
return XmlConvert.ToUInt32(element.InnerText);
}
case "Int64":
{
return XmlConvert.ToInt64(element.InnerText);
}
case "UInt64":
{
return XmlConvert.ToUInt64(element.InnerText);
}
case "Single":
{
return XmlConvert.ToSingle(element.InnerText);
}
case "Double":
{
return XmlConvert.ToDouble(element.InnerText);
}
case "String":
{
return element.InnerText;
}
case "DateTime":
{
return XmlConvert.ToDateTime(element.InnerText, XmlDateTimeSerializationMode.Utc);
}
case "NodeId":
{
XmlNode child = element.FirstChild;
string id = null;
if (GetValue(element, ref child, "Identifier", out id))
{
return new NodeId(id);
}
break;
}
case "ExpandedNodeId":
{
XmlNode child = element.FirstChild;
string id = null;
if (GetValue(element, ref child, "Identifier", out id))
{
return new NodeId(id);
}
break;
}
case "QualifiedName":
{
QualifiedName value = new QualifiedName();
XmlNode child = element.FirstChild;
string namespaceIndex = null;
if (GetValue(element, ref child, "NamespaceIndex", out namespaceIndex))
{
value.NamespaceIndex = XmlConvert.ToUInt16(namespaceIndex);
}
string name = null;
if (GetValue(element, ref child, "Name", out name))
{
value.Name = name;
}
return value;
}
case "LocalizedText":
{
LocalizedText value = new LocalizedText();
XmlNode child = element.FirstChild;
string locale = null;
if (GetValue(element, ref child, "Locale", out locale))
{
value.Locale = locale;
}
string text = null;
if (GetValue(element, ref child, "Text", out text))
{
value.Text = text;
}
return value;
}
case "StatusCode":
{
StatusCode value = new StatusCode();
XmlNode child = element.FirstChild;
string code = null;
if (GetValue(element, ref child, "Code", out code))
{
value.Code = XmlConvert.ToUInt32(code); ;
}
return value;
}
case "ExtensionObject":
{
ExtensionObject value = new ExtensionObject();
XmlNode child = element.FirstChild;
string typeId = null;
if (GetValue(element, ref child, "TypeId", out typeId))
{
value.TypeId = new ExpandedNodeId(typeId);
}
for (XmlNode node = child; node != null; node = node.NextSibling)
{
XmlElement element2 = child as XmlElement;
if (element2 != null)
{
if (element2.Name == "Body")
{
ExtensionObjectBody body = new ExtensionObjectBody();
body.Nodes = new XmlNode[] { GetFirstElement(element2) };
value.Body = body;
}
break;
}
}
return value;
}
}
return null;
}
/// <summary>
/// Invokes the ActivateSession service.
/// </summary>
public virtual ResponseHeader ActivateSession(
RequestHeader requestHeader,
SignatureData clientSignature,
SignedSoftwareCertificateCollection clientSoftwareCertificates,
StringCollection localeIds,
ExtensionObject userIdentityToken,
SignatureData userTokenSignature,
out byte[] serverNonce,
out StatusCodeCollection results,
out DiagnosticInfoCollection diagnosticInfos)
{
serverNonce = null;
results = null;
diagnosticInfos = null;
ValidateRequest(requestHeader);
// Insert implementation.
return CreateResponse(requestHeader, StatusCodes.BadServiceUnsupported);
}
static void HistoryUpdate(Session session)
{
DiagnosticInfoCollection diagnosticInfos;
// translate browse paths.
IList<NodeOfInterest> nodeIds;
nodeIds = GetNodeIds(session, Opc.Ua.Objects.ObjectsFolder,
VariableBrowsePaths.ToArray());
ExtensionObjectCollection eoc = new ExtensionObjectCollection();
for (int ii = 0; ii < nodeIds.Count; ii++)
{
UpdateDataDetails updateDetails = new UpdateDataDetails();
updateDetails.NodeId = nodeIds[ii].NodeId;
updateDetails.PerformInsertReplace = PerformUpdateType.Update;
updateDetails.UpdateValues = new DataValueCollection();
for (int jj = 0; jj <= 5; jj++)
{
DataValue dv = new DataValue(new Variant(jj*10), StatusCodes.Good, new DateTime(2008, 01, 01, 12, 0, jj*2));
updateDetails.UpdateValues.Add(dv);
}
ExtensionObject eo = new ExtensionObject(updateDetails.TypeId, updateDetails);
eoc.Add(eo);
}
HistoryUpdateResultCollection historyUpdateResults;
ResponseHeader responseHeader =
session.HistoryUpdate(null, eoc, out historyUpdateResults, out diagnosticInfos);
// process results.
for (int ii = 0; ii < historyUpdateResults.Count; ii++)
{
HistoryUpdateResult historyUpdateResult = historyUpdateResults[ii];
Console.WriteLine("HistoryUpdate result code for {0}: {1}", VariableBrowsePaths[ii], historyUpdateResult.StatusCode.ToString());
if (StatusCode.IsGood(historyUpdateResult.StatusCode))
{
for (int jj = 0; jj < historyUpdateResult.OperationResults.Count; jj++)
{
Console.WriteLine(" {0}: {1}", jj, historyUpdateResult.OperationResults[jj]);
}
Console.WriteLine("");
}
}
}
/// <summary>
/// Writes an ExtensionObject to the stream.
/// </summary>
public void WriteExtensionObject(string fieldName, ExtensionObject value)
{
if (BeginField(fieldName, value == null, true))
{
PushNamespace(Namespaces.OpcUaXsd);
// check for null.
if (value == null)
{
EndField(fieldName);
PopNamespace();
return;
}
IEncodeable encodeable = value.Body as IEncodeable;
// write the type id.
ExpandedNodeId typeId = value.TypeId;
if (encodeable != null)
{
if (value.Encoding == ExtensionObjectEncoding.Binary)
{
typeId = encodeable.BinaryEncodingId;
}
else
{
typeId = encodeable.XmlEncodingId;
}
}
NodeId localTypeId = ExpandedNodeId.ToNodeId(typeId, m_context.NamespaceUris);
if (NodeId.IsNull(localTypeId) && !NodeId.IsNull(typeId))
{
if (encodeable != null)
{
throw ServiceResultException.Create(
StatusCodes.BadEncodingError,
"Cannot encode bodies of type '{0}' in ExtensionObject unless the NamespaceUri ({1}) is in the encoder's NamespaceTable.",
encodeable.GetType().FullName,
typeId.NamespaceUri);
}
localTypeId = NodeId.Null;
}
WriteNodeId("TypeId", localTypeId);
object body = value.Body;
if (body == null)
{
EndField(fieldName);
PopNamespace();
return;
}
// write the body.
m_writer.WriteStartElement("Body", Namespaces.OpcUaXsd);
WriteExtensionObjectBody(body);
// end of body.
m_writer.WriteEndElement();
EndField(fieldName);
PopNamespace();
}
}
/// <summary>
/// Reads the history of attributes for Bucket Brigade.Int1.
/// </summary>
static void HistoryReadAttributes(Session session)
{
List<string> VariableBrowsePaths = new List<string>();
VariableBrowsePaths.Add("/7:MatrikonOpc Sim Server/7:Simulation Items/7:Bucket Brigade/7:Int1/7:Description");
VariableBrowsePaths.Add("/7:MatrikonOpc Sim Server/7:Simulation Items/7:Bucket Brigade/7:Int1/7:DataType");
VariableBrowsePaths.Add("/7:MatrikonOpc Sim Server/7:Simulation Items/7:Bucket Brigade/7:Int1/7:ITEMID");
// translate browse paths.
IList<NodeOfInterest> nodeIds = GetNodeIds(session, Opc.Ua.Objects.ObjectsFolder,
VariableBrowsePaths.ToArray());
DiagnosticInfoCollection diagnosticInfos;
ReadRawModifiedDetails readDetails = new ReadRawModifiedDetails();
readDetails.StartTime = DateTime.MinValue;
readDetails.EndTime = DateTime.Now;
readDetails.IsReadModified = false;
readDetails.NumValuesPerNode = 100;
readDetails.ReturnBounds = false;
ExtensionObject eo = new ExtensionObject(readDetails.TypeId, readDetails);
HistoryReadValueIdCollection idCollection = new HistoryReadValueIdCollection();
for (int ii = 0; ii < nodeIds.Count; ii++)
{
HistoryReadValueId readValueId = new HistoryReadValueId();
readValueId.NodeId = nodeIds[ii].NodeId;
readValueId.Processed = false;
idCollection.Add(readValueId);
}
HistoryReadResultCollection historyReadResults;
ResponseHeader responseHeader =
session.HistoryRead(null, eo, TimestampsToReturn.Both, true,
idCollection, out historyReadResults, out diagnosticInfos);
// process results.
for (int ii = 0; ii < historyReadResults.Count; ii++)
{
HistoryReadResult historyReadResult = historyReadResults[ii];
HistoryData historyData = null;
DataValueCollection dataValues = null;
if (historyReadResult.HistoryData != null)
{
historyData = ExtensionObject.ToEncodeable(historyReadResult.HistoryData) as HistoryData;
dataValues = historyData.DataValues;
}
ServiceResult result = Session.GetResult(historyReadResult.StatusCode, ii, diagnosticInfos, responseHeader);
Console.WriteLine("\nHistoryRead result code for {0}: {1}", VariableBrowsePaths[ii], result.StatusCode.ToString());
if (StatusCode.IsBad(historyReadResult.StatusCode))
{
continue;
}
if (dataValues == null)
{
Console.WriteLine("dataValues == null");
continue;
}
for (int jj = 0; jj < dataValues.Count; jj++)
{
DataValue dataValue = dataValues[jj];
// write value.
Console.WriteLine("\t{0}: V={1}",jj, dataValue.Value == null ? "null" : dataValue.Value.ToString());
Console.WriteLine("\t Q={0}, SrvT={1}, SrcT={2}\n",
dataValue.StatusCode.ToString(), dataValue.ServerTimestamp, dataValue.SourceTimestamp);
}
}
}
/// <summary>
/// Validates the monitoring filter specified by the client.
/// </summary>
protected virtual StatusCode ValidateMonitoringFilter(
ServerSystemContext context,
NodeHandle handle,
uint attributeId,
double samplingInterval,
uint queueSize,
ExtensionObject filter,
out MonitoringFilter filterToUse,
out Range range,
out MonitoringFilterResult result)
{
range = null;
filterToUse = null;
result = null;
// nothing to do if the filter is not specified.
if (ExtensionObject.IsNull(filter))
{
return StatusCodes.Good;
}
// extension objects wrap any data structure. must check that the client provided the correct structure.
DataChangeFilter deadbandFilter = ExtensionObject.ToEncodeable(filter) as DataChangeFilter;
if (deadbandFilter == null)
{
AggregateFilter aggregateFilter = ExtensionObject.ToEncodeable(filter) as AggregateFilter;
if (aggregateFilter == null || attributeId != Attributes.Value)
{
return StatusCodes.BadFilterNotAllowed;
}
if (!Server.AggregateManager.IsSupported(aggregateFilter.AggregateType))
{
return StatusCodes.BadAggregateNotSupported;
}
ServerAggregateFilter revisedFilter = new ServerAggregateFilter();
revisedFilter.AggregateType = aggregateFilter.AggregateType;
revisedFilter.StartTime = aggregateFilter.StartTime;
revisedFilter.ProcessingInterval = aggregateFilter.ProcessingInterval;
revisedFilter.AggregateConfiguration = aggregateFilter.AggregateConfiguration;
revisedFilter.Stepped = false;
StatusCode error = ReviseAggregateFilter(context, handle, samplingInterval, queueSize, revisedFilter);
if (StatusCode.IsBad(error))
{
return error;
}
AggregateFilterResult aggregateFilterResult = new AggregateFilterResult();
aggregateFilterResult.RevisedProcessingInterval = aggregateFilter.ProcessingInterval;
aggregateFilterResult.RevisedStartTime = aggregateFilter.StartTime;
aggregateFilterResult.RevisedAggregateConfiguration = aggregateFilter.AggregateConfiguration;
filterToUse = revisedFilter;
result = aggregateFilterResult;
return StatusCodes.Good;
}
// deadband filters only allowed for variable values.
if (attributeId != Attributes.Value)
{
return StatusCodes.BadFilterNotAllowed;
}
BaseVariableState variable = handle.Node as BaseVariableState;
if (variable == null)
{
return StatusCodes.BadFilterNotAllowed;
}
// check for status filter.
if (deadbandFilter.DeadbandType == (uint)DeadbandType.None)
{
filterToUse = deadbandFilter;
return StatusCodes.Good;
}
// deadband filters can only be used for numeric values.
if (!Server.TypeTree.IsTypeOf(variable.DataType, DataTypeIds.Number))
{
return StatusCodes.BadFilterNotAllowed;
}
// nothing more to do for absolute filters.
if (deadbandFilter.DeadbandType == (uint)DeadbandType.Absolute)
{
filterToUse = deadbandFilter;
return StatusCodes.Good;
}
// need to look up the EU range if a percent filter is requested.
if (deadbandFilter.DeadbandType == (uint)DeadbandType.Percent)
{
PropertyState property = handle.Node.FindChild(context, Opc.Ua.BrowseNames.EURange) as PropertyState;
if (property == null)
{
return StatusCodes.BadFilterNotAllowed;
}
range = property.Value as Range;
if (range == null)
{
return StatusCodes.BadFilterNotAllowed;
}
filterToUse = deadbandFilter;
return StatusCodes.Good;
}
// no other type of filter supported.
return StatusCodes.BadFilterNotAllowed;
}
/// <summary>
/// Applies the data encoding to the value.
/// </summary>
public static ServiceResult ApplyDataEncoding(ServiceMessageContext context, QualifiedName dataEncoding, ref object value)
{
// check if nothing to do.
if (QualifiedName.IsNull(dataEncoding) || value == null)
{
return ServiceResult.Good;
}
// check for supported encoding type.
if (dataEncoding.NamespaceIndex != 0)
{
return StatusCodes.BadDataEncodingUnsupported;
}
bool useXml = dataEncoding.Name == DefaultXml;
if (!useXml && dataEncoding.Name != DefaultBinary)
{
return StatusCodes.BadDataEncodingUnsupported;
}
try
{
// check for array of encodeables.
IList<IEncodeable> encodeables = value as IList<IEncodeable>;
if (encodeables == null)
{
// check for array of extension objects.
IList<ExtensionObject> extensions = value as IList<ExtensionObject>;
if (extensions != null)
{
// convert extension objects to encodeables.
encodeables = new IEncodeable[extensions.Count];
for (int ii = 0; ii < encodeables.Count; ii++)
{
if (ExtensionObject.IsNull(extensions[ii]))
{
encodeables[ii] = null;
continue;
}
IEncodeable element = extensions[ii].Body as IEncodeable;
if (element == null)
{
return StatusCodes.BadTypeMismatch;
}
encodeables[ii] = element;
}
}
}
// apply data encoding to the array.
if (encodeables != null)
{
ExtensionObject[] extensions = new ExtensionObject[encodeables.Count];
for (int ii = 0; ii < extensions.Length; ii++)
{
extensions[ii] = Encode(context, encodeables[ii], useXml);
}
value = extensions;
return ServiceResult.Good;
}
// check for scalar value.
IEncodeable encodeable = value as IEncodeable;
if (encodeable == null)
{
ExtensionObject extension = value as ExtensionObject;
if (extension == null)
{
return StatusCodes.BadDataEncodingUnsupported;
}
encodeable = extension.Body as IEncodeable;
}
if (encodeable == null)
{
return StatusCodes.BadDataEncodingUnsupported;
}
// do conversion.
value = Encode(context, encodeable, useXml);
return ServiceResult.Good;
}
catch (Exception e)
{
return ServiceResult.Create(e, StatusCodes.BadTypeMismatch, "Could not convert value to requested format.");
}
}
/// <summary>
/// Applies the data encoding to the value.
/// </summary>
public static ServiceResult ApplyDataEncoding(ServiceMessageContext context, QualifiedName dataEncoding, ref object value)
{
// check if nothing to do.
if (QualifiedName.IsNull(dataEncoding) || value == null)
{
return(ServiceResult.Good);
}
// check for supported encoding type.
if (dataEncoding.NamespaceIndex != 0)
{
return(StatusCodes.BadDataEncodingUnsupported);
}
bool useXml = dataEncoding.Name == DefaultXml;
if (!useXml && dataEncoding.Name != DefaultBinary)
{
return(StatusCodes.BadDataEncodingUnsupported);
}
try
{
// check for array of encodeables.
IList <IEncodeable> encodeables = value as IList <IEncodeable>;
if (encodeables == null)
{
// check for array of extension objects.
IList <ExtensionObject> extensions = value as IList <ExtensionObject>;
if (extensions != null)
{
// convert extension objects to encodeables.
encodeables = new IEncodeable[extensions.Count];
for (int ii = 0; ii < encodeables.Count; ii++)
{
if (ExtensionObject.IsNull(extensions[ii]))
{
encodeables[ii] = null;
continue;
}
IEncodeable element = extensions[ii].Body as IEncodeable;
if (element == null)
{
return(StatusCodes.BadTypeMismatch);
}
encodeables[ii] = element;
}
}
}
// apply data encoding to the array.
if (encodeables != null)
{
ExtensionObject[] extensions = new ExtensionObject[encodeables.Count];
for (int ii = 0; ii < extensions.Length; ii++)
{
extensions[ii] = Encode(context, encodeables[ii], useXml);
}
value = extensions;
return(ServiceResult.Good);
}
// check for scalar value.
IEncodeable encodeable = value as IEncodeable;
if (encodeable == null)
{
ExtensionObject extension = value as ExtensionObject;
if (extension == null)
{
return(StatusCodes.BadDataEncodingUnsupported);
}
encodeable = extension.Body as IEncodeable;
}
if (encodeable == null)
{
return(StatusCodes.BadDataEncodingUnsupported);
}
// do conversion.
value = Encode(context, encodeable, useXml);
return(ServiceResult.Good);
}
catch (Exception e)
{
return(ServiceResult.Create(e, StatusCodes.BadTypeMismatch, "Could not convert value to requested format."));
}
}
/// <summary>
/// Creates a deep copy of the value.
/// </summary>
/// <param name="value">The value to be copied.</param>
/// <remarks>
/// Creates a deep copy of the value.
/// </remarks>
/// <exception cref="ArgumentNullException">Thrown when the value is null</exception>
public ExtensionObject(ExtensionObject value) {
if (value == null) throw new ArgumentNullException("value");
TypeId = value.TypeId;
Body = Utils.Clone(value.Body);
}
